# The lex records whose category is structural-patterns

This index as JSON: https://banes-lab.com/json/api/facets/lex/category/structural-patterns

## Entries

- [Cartesian Inheritance Explosion](https://banes-lab.com/records/lex/cartesian-inheritance-explosion.md): Modeling every combination of two independent dimensions as its own subclass, so the class count grows multiplicatively.
- [Direct Access](https://banes-lab.com/records/lex/direct-access.md): Reaching a resource directly with no intermediary, bypassing the access control, caching, or laziness a proxy would add.
- [Direct External Coupling](https://banes-lab.com/records/lex/direct-external-coupling.md): Coupling code directly to an incompatible external interface, spreading its idiosyncrasies through the codebase.
- [Leaf-vs-Container Special-Casing](https://banes-lab.com/records/lex/leaf-vs-container-special-casing.md): Branching client code on whether an element is a leaf or a container instead of treating them through one interface.
- [Leaky Subsystem API](https://banes-lab.com/records/lex/leaky-subsystem-api.md): Exposing a subsystem's internal complexity directly to clients instead of hiding it behind a simplifying interface.
- [Per-Instance Duplicate State](https://banes-lab.com/records/lex/per-instance-duplicate-state.md): Storing identical shared state separately in every object instance, wasting memory at high object counts.
- [Subclass Explosion](https://banes-lab.com/records/lex/subclass-explosion.md): Creating a distinct subclass for every combination of optional features instead of composing them at runtime.
- [High-Cardinality Object Reuse](https://banes-lab.com/records/lex/high-cardinality-object-reuse.md): The ability to represent large numbers of similar objects economically by sharing their common intrinsic state.
- [Implementation Swap](https://banes-lab.com/records/lex/implementation-swap.md): The ability to change an abstraction's underlying implementation without altering the abstraction itself.
- [Lazy Load](https://banes-lab.com/records/lex/lazy-load.md): The ability to defer creating or loading a costly resource until it is first used.
- [Leaf/Composite Transparency](https://banes-lab.com/records/lex/leaf-composite-transparency.md): The ability to treat individual objects and compositions of objects through one uniform interface.
- [Recursive Composition](https://banes-lab.com/records/lex/recursive-composition.md): The ability to build tree structures in which composites contain other composites to arbitrary depth.
- [Runtime Behavior Extension](https://banes-lab.com/records/lex/runtime-behavior-extension.md): The ability to add responsibilities to an object dynamically at runtime by wrapping it.
- [Shared Immutable State](https://banes-lab.com/records/lex/shared-immutable-state.md): The ability to safely share one immutable state object across many contexts at once.
- [Simplified Access](https://banes-lab.com/records/lex/simplified-access.md): The ability to use a complex subsystem through a small, convenient interface.
- [Remote Stub](https://banes-lab.com/records/lex/remote-stub.md): A local stand-in object that forwards calls to an object living in another process or machine.
- [Common Interface](https://banes-lab.com/records/lex/common-interface.md): The requirement that a wrapper and the object it wraps share one interface so they remain interchangeable.
- [Incompatible Interfaces](https://banes-lab.com/records/lex/incompatible-interfaces.md): A precondition of two interfaces that must cooperate yet expose mismatched signatures.
- [Independent Variation Axes](https://banes-lab.com/records/lex/independent-variation-axes.md): The requirement that an abstraction and its implementation vary along separate axes so they can be decoupled.
- [Separable Intrinsic State](https://banes-lab.com/records/lex/separable-intrinsic-state.md): The requirement that an object's shared, context-independent state be separable from its per-use state.
- [Uniform Component Interface](https://banes-lab.com/records/lex/uniform-component-interface.md): The requirement that leaves and composites implement one shared interface so clients treat them alike.
- [Indirection](https://banes-lab.com/records/lex/indirection.md): The degree of extra indirection introduced by separating an abstraction from its implementation.
- [Over-Centralization](https://banes-lab.com/records/lex/over-centralization.md): The degree to which routing all access through one facade concentrates responsibility and can bottleneck change.
- [Stack Debugging](https://banes-lab.com/records/lex/stack-debugging.md): The degree to which layers of wrapping deepen the call stack and complicate debugging.
- [Subsystem Complexity](https://banes-lab.com/records/lex/subsystem-complexity.md): The degree of internal complexity in a subsystem that motivates hiding it behind a facade.
- [Transparency / Debugging](https://banes-lab.com/records/lex/transparency-debugging.md): The degree to which interposing a proxy hides the real object and complicates tracing calls to it.