Glossary

Most Relevant Terms in Systems Design

Load Balancing: Distributes incoming traffic across multiple servers to ensure high availability and reliability.
Sharding: Divides data into smaller, manageable pieces stored across multiple databases.
CAP Theorem: States that a distributed system can achieve at most two of Consistency, Availability, and Partition Tolerance.
ACID: Database properties ensuring Atomicity, Consistency, Isolation, and Durability.
BASE: An alternative to ACID prioritizing Availability and eventual consistency in distributed systems.
Eventual Consistency: Guarantees data consistency over time, given no new updates occur.
Leader Election: A consensus algorithm to designate a single leader node in distributed systems.
Replication: Copies data across multiple nodes for redundancy and faster access.
Quorum: Minimum number of nodes agreeing to maintain consistency in distributed systems.
Microservices: Architectural style splitting applications into independently deployable services.
Monolithic Architecture: A single, unified application architecture tightly coupled in design.
Service Discovery: Mechanism for dynamically locating network services within a system.
Caching: Storing data in temporary storage for faster retrieval.
Reverse Proxy: Forwards client requests to backend servers, improving performance and security.
Content Delivery Network (CDN): Distributes web content across geographically dispersed servers.
Rate Limiting: Controls the rate of incoming requests to prevent overloading.
Circuit Breaker: Prevents a system from calling a failing service repeatedly.
Throttling: Restricts request rates from clients or services.
Backpressure: A mechanism to handle overwhelmed systems by signaling senders to slow down.
Queueing: Temporary storage of tasks to ensure smooth processing.
Idempotency: Ensures operations have the same effect regardless of repeated execution.
Vertical Scaling: Increasing resources of a single server to handle higher load.
Horizontal Scaling: Adding more servers to distribute the load.
Autoscaling: Dynamically adjusts resources based on real-time demand.
Latency: Time delay in a system’s response to a request.
Throughput: Number of transactions processed in a given timeframe.
Fault Tolerance: Ability of a system to continue operation after failure.
Failover: Automatically transferring services to a backup system in case of failure.
Redundancy: Adding extra components to ensure availability during failures.
Data Partitioning: Divides large datasets into smaller, manageable segments.
Distributed Hash Table (DHT): A decentralized system for mapping keys to values.
Consensus Algorithms: Methods like Paxos or Raft for agreement among distributed nodes.
Time to Live (TTL): Expiration time set for data in cache or system resources.
Health Checks: Monitors system components to ensure availability and functionality.
Distributed System: A network of independent computers acting as a single system.
Deadlock: A state where processes are stuck, waiting for each other’s resources.
Race Condition: A timing issue causing unpredictable outcomes in concurrent systems.
Distributed Tracing: Tracks requests across microservices for debugging and monitoring.
Service Mesh: Layer managing service-to-service communication in microservices.
Observability: Measures how well internal states can be inferred from system outputs.
Telemetry: Collection of metrics and logs for monitoring system health.
Message Broker: Facilitates communication by routing messages between systems.
Pub/Sub: Asynchronous messaging pattern for decoupling publishers and subscribers.
Schema Evolution: Managing changes to data structures over time.
Indexing: Optimizes query performance by structuring data for fast retrieval.
Elasticity: Ability of a system to scale up or down as needed.
Immutable Infrastructure: Deploying systems without making modifications to existing components.
Data Lake: Centralized repository for storing structured and unstructured data.
Zookeeper: A distributed coordination service for managing configuration and synchronization.
Shadow Testing: Testing new features on production traffic without user visibility.
Byzantine Fault Tolerance (BFT): Ensures a distributed system continues operating even when some nodes act maliciously.
CRDTs (Conflict-Free Replicated Data Types): Data structures allowing concurrent updates without conflicts in distributed systems.
Erasure Coding: Breaks data into fragments, allowing recovery from partial data loss.
Quorum Consensus: A technique to ensure strong consistency by requiring a majority of nodes to agree on operations.
Distributed Consensus: Agreement among distributed systems on a single data value, critical for reliability.
Vector Clocks: Tracks the causal relationship of events in distributed systems.
Geo-Partitioning: Segments data based on geographic locations to optimize latency and compliance.
Merkle Tree: Hash-based tree structure for efficient verification of data integrity.
Raft Algorithm: A consensus algorithm emphasizing understandability and safety for distributed systems.
Gossip Protocol: Spreads information across nodes in a network efficiently and fault-tolerantly.
Write-Ahead Logging (WAL): Logs changes before applying them to ensure durability and recovery.
Distributed Transaction Coordination: Manages transactions across distributed systems using techniques like 2PC or 3PC.
SAGA Pattern: A distributed transaction pattern breaking complex workflows into smaller, compensable transactions.
Chaos Engineering: Deliberately introducing failures to test system resilience.
Hot Sharding: Handling imbalance in shard traffic by dynamically redistributing load.
Strong Eventual Consistency (SEC): Ensures both consistency and availability in highly distributed systems over time.
Leader-Follower Replication: Leader node writes data, and followers replicate for high read throughput.
Consistent Hashing: Maps keys to nodes in a way that minimizes reassignments during scaling.
Skewed Workload Mitigation: Addressing imbalances caused by uneven distribution of workload in distributed systems.
Distributed Lock Management: Synchronizes resource access across distributed nodes using algorithms like Redlock.