# Lexicon terms whose category is codebase-system-architecture-styles

> 38 records

This index as JSON: https://banes-lab.com/json/api/facets/lexicon/category/codebase-system-architecture-styles

## Entries

- [Central Database Bottleneck](https://banes-lab.com/records/lexicon/central-database-bottleneck.md): Funneling all state through one shared database that becomes the system's scaling bottleneck.
- [Framework-Centric Core](https://banes-lab.com/records/lexicon/framework-centric-core.md): Building the core around a specific framework, so the framework's concerns permeate the domain.
- [Layer Leakage](https://banes-lab.com/records/lexicon/layer-leakage.md): Letting an inner layer depend on an outer one, violating the direction of the dependency rule.
- [Layer Skipping](https://banes-lab.com/records/lexicon/layer-skipping.md): Bypassing intermediate layers to call a distant layer directly, undermining the layering.
- [Monolithic Transform Function](https://banes-lab.com/records/lexicon/monolithic-transform-function.md): Doing all processing in one large transform instead of a series of composable filter stages.
- [Package by Technical Layer Only](https://banes-lab.com/records/lexicon/package-by-technical-layer-only.md): Organizing code by technical layer alone, scattering each feature across many packages.
- [Shared Monolithic Application](https://banes-lab.com/records/lexicon/shared-monolithic-application.md): Building one large shared application instead of composing independently-governed services.
- [Unbounded Big Ball of Mud](https://banes-lab.com/records/lexicon/unbounded-big-ball-of-mud.md): Letting a system grow without structure into a tangled mass with no clear boundaries.
- [Contract-Governed Service Reuse](https://banes-lab.com/records/lexicon/contract-governed-service-reuse.md): The ability to reuse services across an enterprise through well-defined contracts.
- [Database-Bottleneck Removal](https://banes-lab.com/records/lexicon/database-bottleneck-removal.md): The ability to eliminate the shared-database bottleneck by holding state in distributed memory.
- [Decentralized Ownership](https://banes-lab.com/records/lexicon/decentralized-ownership.md): The ability for separate teams to own, deploy and evolve their services independently.
- [External System Isolation](https://banes-lab.com/records/lexicon/external-system-isolation.md): The ability to isolate the core from external systems behind adapter boundaries.
- [Framework Independence](https://banes-lab.com/records/lexicon/framework-independence.md): The ability to keep business rules independent of any particular framework.
- [Independent Stage Testing](https://banes-lab.com/records/lexicon/independent-stage-testing.md): The ability to test each filter stage in isolation from the rest of the pipeline.
- [Infrastructure Independence](https://banes-lab.com/records/lexicon/infrastructure-independence.md): The ability to keep the core independent of the infrastructure it runs on.
- [Locality of Change](https://banes-lab.com/records/lexicon/locality-of-change.md): The ability to make a feature's changes in one place because its code is grouped together.
- [Reorderable Stages](https://banes-lab.com/records/lexicon/reorderable-stages.md): The ability to reorder or recombine independent processing stages.
- [Structured Code Organization](https://banes-lab.com/records/lexicon/structured-code-organization.md): The ability to organize code predictably by assigning each responsibility to a layer.
- [Transactional Simplicity](https://banes-lab.com/records/lexicon/transactional-simplicity.md): The ability to use straightforward local transactions when all state lives in one process.
- [Adapters](https://banes-lab.com/records/lexicon/adapters.md): Components that translate between a core's ports and the specific external technologies behind them.
- [Boundaries](https://banes-lab.com/records/lexicon/boundaries.md): The requirement that clear boundaries separate the concentric layers of the system.
- [Component Boundaries](https://banes-lab.com/records/lexicon/component-boundaries.md): The requirement that each component expose a well-defined boundary and interface.
- [Dependency Rule](https://banes-lab.com/records/lexicon/dependency-rule.md): The requirement that source-code dependencies point only inward, toward higher-level policy.
- [Domain Core](https://banes-lab.com/records/lexicon/domain-core.md): The requirement that pure domain logic occupy the core, isolated from external concerns.
- [Layer Separation](https://banes-lab.com/records/lexicon/layer-separation.md): The requirement that responsibilities be divided into distinct, ordered layers.
- [Ports](https://banes-lab.com/records/lexicon/ports.md): The requirement that the core define abstract interface points through which all external interaction passes.
- [Replicated In-Memory State](https://banes-lab.com/records/lexicon/replicated-in-memory-state.md): The requirement that application state be kept in replicated in-memory grids rather than a central store.
- [Unified Deployment Boundary](https://banes-lab.com/records/lexicon/unified-deployment-boundary.md): The requirement that the whole application build and deploy as one unit.
- [Uniform Stage Interface](https://banes-lab.com/records/lexicon/uniform-stage-interface.md): The requirement that every stage share one interface so stages can be composed freely.
- [Use Cases](https://banes-lab.com/records/lexicon/use-cases.md): The requirement that application operations be captured as explicit use cases in their own layer.
- [Anemic Layers](https://banes-lab.com/records/lexicon/anemic-layers.md): The degree to which strict layering produces thin pass-through layers that add indirection without logic.
- [End-to-End Traceability](https://banes-lab.com/records/lexicon/end-to-end-traceability.md): The degree to which decomposing flow into independent filters makes tracing a request end to end harder.
- [Feature Cohesion](https://banes-lab.com/records/lexicon/feature-cohesion.md): The degree to which all code serving one feature is grouped together rather than scattered by layer.
- [Independent Scaling](https://banes-lab.com/records/lexicon/independent-scaling.md): The degree to which a single deployable unit prevents scaling parts of the system independently.
- [Initial Complexity](https://banes-lab.com/records/lexicon/initial-complexity.md): The degree of upfront structural complexity introduced by defining ports and adapters.
- [Integration Overhead](https://banes-lab.com/records/lexicon/integration-overhead.md): The degree of effort required to wire independently-developed components together.
- [Operational Simplicity](https://banes-lab.com/records/lexicon/operational-simplicity.md): The degree to which a single deployable unit keeps building, deploying, and operating simple.
- [Shared Technical Concerns](https://banes-lab.com/records/lexicon/shared-technical-concerns.md): The degree to which grouping by feature complicates sharing cross-cutting technical code.