# Architecture principles whose scope is runtime

> 43 records

This index as JSON: https://banes-lab.com/json/api/facets/architecture/scope/runtime

## Entries

- [Runtime Discovery](https://banes-lab.com/records/architecture/runtime-discovery.md): 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.
- [Service Discovery](https://banes-lab.com/records/architecture/service-discovery.md): A mechanism that resolves a service name to a healthy network endpoint at call time through a registry.
- [Dynamic Binding](https://banes-lab.com/records/architecture/dynamic-binding.md): 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.
- [Dynamic Dispatch](https://banes-lab.com/records/architecture/dynamic-dispatch.md): A mechanism that chooses which operation runs from the receiver or a keyed table at runtime, replacing a conditional over kinds.
- [Runtime Extensibility](https://banes-lab.com/records/architecture/runtime-extensibility.md): The degree to which new capability can be added to a running system through extension points, without modifying its core.
- [Dependency Graph](https://banes-lab.com/records/architecture/dependency-graph.md): Descriptive data about which modules, tasks or services depend on which, extracted as a directed graph.
- [Centralized Configuration](https://banes-lab.com/records/architecture/centralized-configuration.md): A design pattern that keeps every service's configuration in one versioned store the services read from.
- [Predictability](https://banes-lab.com/records/architecture/predictability.md): The degree to which a caller can foresee what an operation does from its interface and contract.
- [Portability](https://banes-lab.com/records/architecture/portability.md): The degree to which software runs on another platform or environment without code changes.
- [Platform Independence](https://banes-lab.com/records/architecture/platform-independence.md): A design rule that portable layers reach the operating system and vendor services only through abstractions.
- [Containerization](https://banes-lab.com/records/architecture/containerization.md): A mechanism that packages an application with its runtime dependencies into an image that runs the same on any host.
- [Configuration Externalization](https://banes-lab.com/records/architecture/configuration-externalization.md): A design rule that environment-specific values are read from validated external configuration at startup.
- [Polymorphism](https://banes-lab.com/records/architecture/polymorphism.md): A mechanism that lets one interface have several implementations, with the implementation chosen by the object that receives the call.
- [Fail Safe](https://banes-lab.com/records/architecture/fail-safe.md): A design rule that a failing operation leaves the system in the state that causes the least harm.
- [Bulkhead Pattern](https://banes-lab.com/records/architecture/bulkhead-pattern.md): A design pattern that gives each workload its own pool of threads or connections, so one workload cannot exhaust the others.
- [Self-Describing Architecture](https://banes-lab.com/records/architecture/self-describing-architecture.md): A design rule that each module declares its name, version, capabilities and requirements in metadata that tools and the runtime can read.
- [Self-Describing Structures](https://banes-lab.com/records/architecture/self-describing-structures.md): A design rule that a data structure carries its own type tags and field names, so a reader can interpret it without outside knowledge.
- [Metadata-Driven Design](https://banes-lab.com/records/architecture/metadata-driven-design.md): An approach in which behavior such as forms, routes or plugins is generated from validated metadata instead of written case by case.
- [Declarative Configuration](https://banes-lab.com/records/architecture/declarative-configuration.md): A design rule that a system's settings are declared as validated data, and the system configures itself from that data.
- [Capability Declaration](https://banes-lab.com/records/architecture/capability-declaration.md): A mechanism by which a plugin or service lists the operations it supports, so callers test the list instead of probing for methods.
- [Code as Data](https://banes-lab.com/records/architecture/code-as-data.md): 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.
- [Metaprogramming](https://banes-lab.com/records/architecture/metaprogramming.md): A technique for writing programs that generate or transform other programs, at compile time or at runtime.
- [Reflection](https://banes-lab.com/records/architecture/reflection.md): A mechanism that lets a program read and act on type metadata about its own structure at runtime.
- [Introspection](https://banes-lab.com/records/architecture/introspection.md): A mechanism that lets a program query an object's type and public members at runtime without changing them.
- [Runtime Code Generation](https://banes-lab.com/records/architecture/runtime-code-generation.md): A mechanism that builds executable code while the program runs, from a specification such as a field mapping.
- [Observability](https://banes-lab.com/records/architecture/observability.md): The degree to which a system's internal behavior in production can be inferred from the logs, metrics and traces it emits.
- [Observer Pattern](https://banes-lab.com/records/architecture/observer-pattern.md): A design pattern in which a subject publishes events to subscribers it does not know by name.
- [Prototype Pattern](https://banes-lab.com/records/architecture/prototype-pattern.md): A design pattern that creates new objects by cloning a prepared template and applying overrides.
- [Concurrency](https://banes-lab.com/records/architecture/concurrency.md): A conceptual representation of several tasks in progress over overlapping time, with their access to shared state coordinated.
- [Parallelism](https://banes-lab.com/records/architecture/parallelism.md): A technique for running independent units of work at the same time on several cores or workers.
- [Profiling](https://banes-lab.com/records/architecture/profiling.md): A technique for measuring where a running program spends its time and memory under a representative workload.
- [Plugin Architecture](https://banes-lab.com/records/architecture/plugin-architecture.md): A convention of building a small core that discovers and loads plugins through declared extension points.
- [Inversion of Control (IoC)](https://banes-lab.com/records/architecture/inversion-of-control.md): A design rule that a framework or composition root owns object creation and control flow, and application code supplies the parts it calls.
- [Service Registry](https://banes-lab.com/records/architecture/service-registry.md): A mechanism where services or plugins register under a key and are resolved by that key at runtime.
- [Registry Pattern](https://banes-lab.com/records/architecture/registry-pattern.md): A design pattern that replaces a conditional over kinds with a keyed table that each kind registers itself into.
- [Service Locator Pattern](https://banes-lab.com/records/architecture/service-locator-pattern.md): A design pattern in which code fetches its dependencies from a global registry at the point of use.
- [Feature Toggle](https://banes-lab.com/records/architecture/feature-toggle.md): 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.
- [Self-Healing Architecture](https://banes-lab.com/records/architecture/self-healing-architecture.md): The ability of a system to detect a failed component from its health signals and restore it without human action.
- [Health Checks](https://banes-lab.com/records/architecture/health-checks.md): A mechanism that reports whether an instance and the dependencies it needs are ready to serve, so routing and restarts can act on it.
- [Auto-Remediation](https://banes-lab.com/records/architecture/auto-remediation.md): 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.
- [Graceful Shutdown](https://banes-lab.com/records/architecture/graceful-shutdown.md): A mechanism that, on a stop signal, stops accepting work, drains in-flight work and closes connections before the process exits.
- [Secrets Management](https://banes-lab.com/records/architecture/secrets-management.md): The practice of keeping credentials in a secret store, reading them at runtime and rotating them on a schedule.
- [Policy Enforcement](https://banes-lab.com/records/architecture/policy-enforcement.md): A mechanism that blocks an action a policy forbids at the point the action is attempted.