Alphabetical concept index

All topics · Home

Find a term and follow its links to the relevant categories.

A

• ABA problem — Concurrency and parallelism
• ABAC — Security and privacy
• ABI — Languages and runtimes
• abstention — Prompt engineering
• Abstention — Planning, reasoning, and verification
• acceptable error rates — Principal-level applied AI judgment
• access-control metadata — Knowledge-base ingestion
• access-controlled telemetry — LLM observability and debugging
• access-pattern-driven modeling — Nonrelational databases and search
• Accessibility — Frontend and client engineering, LLM application UX
• accounting — Security and privacy
• ACID — Transactions and concurrency control
• Acknowledgments — Messaging and durable workflows
• action previews — Actions and side-effect safety
• action provenance — Actions and side-effect safety
• Action severity — Principal-level applied AI judgment
• action-result feedback — Agent loop engineering
• actionable alerts — Observability and debugging
• active expiration — Distributed key-value stores and Redis
• Actor model — Concurrency and parallelism
• adapter — Code design and maintainability
• adaptive concurrency — Rate limiting and admission control
• admission control — Rate limiting and admission control, LLM performance and cost
• admission policy — Caching
• adoption strategy — Principal-level applied AI judgment
• ADRs — Architecture and domain modeling
• Adversarial cases — Evaluation engineering
• adversarial evaluation — LLM application security
• advisory locks — Transactions and concurrency control
• Agent harness — Agent harness and orchestration
• aggregate invariants — Architecture and domain modeling
• aggregates — Architecture and domain modeling
• AI suitability — Principal-level applied AI judgment
• alert fatigue — Observability and debugging
• Algebraic data types — Languages and runtimes
• aliasing — Languages and runtimes
• ambiguity handling — Prompt engineering
• ambiguous outcomes — Model behavior and API integration
• Ambiguous outcomes — Actions and side-effect safety
• Amdahl’s Law — Performance and capacity
• amortized analysis — Algorithms and data structures
• analyzers — Nonrelational databases and search
• ANN — Retrieval and RAG
• anonymization — Security and privacy
• anti-corruption layers — Architecture and domain modeling
• Anti-entropy — Distributed systems
• AOF — Distributed key-value stores and Redis
• AOF rewrite — Distributed key-value stores and Redis
• AOT — Languages and runtimes
• API contracts — APIs and integrations
• API scopes — APIs and integrations
• appendfsync — Distributed key-value stores and Redis
• application failures — LLM observability and debugging
• application-specific harness — Principal-level applied AI judgment
• approval binding — Actions and side-effect safety
• Approval bypass — LLM application security
• approval UX — LLM application UX
• approval workflows — SaaS and business workflows
• approvals — Actions and side-effect safety
• approved state — LLM application UX
• approximate nearest neighbors — Nonrelational databases and search
• architecture fitness functions — Architecture and domain modeling
• architecture governance — Technical strategy and architecture judgment
• argument correctness — Evaluation engineering
• argument validation — Tools, function calling, and MCP
• Arrays — Algorithms and data structures
• artifact inspection — Planning, reasoning, and verification
• artifact management — Agent harness and orchestration
• artifact promotion — Testing and delivery
• artifact signing — Security and privacy
• ASK — Distributed key-value stores and Redis
• asynchronous I/O — Operating systems and hardware
• asynchronous replication — Distributed systems, Distributed key-value stores and Redis
• asynchronous tools — Tools, function calling, and MCP
• at-least-once — Messaging and durable workflows
• At-most-once — Messaging and durable workflows
• atomic rename — Operating systems and hardware
• atomic updates — Rate limiting and admission control
• atomicity — Concurrency and parallelism, Distributed key-value stores and Redis
• attack surface — Security and privacy
• audio buffering — Multimodal application integration
• audio inputs — Multimodal application integration
• audit evidence — Principal-level applied AI judgment
• audit trails — Security and privacy, Tools, function calling, and MCP
• Audit trails — SaaS and business workflows
• Auditability — Actions and side-effect safety
• Authentication — APIs and integrations, Security and privacy
• authority — Context engineering
• authorization — APIs and integrations, Security and privacy
• Authorization — Tools, function calling, and MCP
• autocommit — Transactions and concurrency control
• automation boundaries — Principal-level applied AI judgment
• autoscaling — Infrastructure and cloud
• autoscaling lag — Performance and capacity
• Availability — Reliability and resilience
• Avro — Data engineering

B

• B+ trees — Algorithms and data structures
• B-trees — Algorithms and data structures
• backfills — Relational databases and SQL, Data engineering, Knowledge-base ingestion
• backpressure — Concurrency and parallelism, Messaging and durable workflows, LLM performance and cost
• backtracking — Algorithms and data structures
• backward compatibility — APIs and integrations
• balanced search trees — Algorithms and data structures
• barge-in — Multimodal application integration
• barriers — Concurrency and parallelism
• batch processing — Data engineering
• batching — Relational databases and SQL
• Batching — Performance and capacity, LLM performance and cost
• benchmark bias — Performance and capacity
• BFS — Algorithms and data structures
• Bi-encoders — Retrieval and RAG
• big keys — Distributed key-value stores and Redis
• Big O — Algorithms and data structures
• Big Omega — Algorithms and data structures
• Big Theta — Algorithms and data structures
• billing reconciliation — SaaS and business workflows
• Binary search — Algorithms and data structures
• bitmaps — Distributed key-value stores and Redis
• blast radius — Reliability and resilience
• blob storage — Nonrelational databases and search
• blocking commands — Distributed key-value stores and Redis
• Blocking I/O — Operating systems and hardware
• Bloom filters — Algorithms and data structures
• blue-green deployment — Testing and delivery
• BM25 — Nonrelational databases and search, Retrieval and RAG
• BOLA — Security and privacy
• borrowing — Languages and runtimes
• boundary bursts — Rate limiting and admission control
• Bounded contexts — Architecture and domain modeling
• bounded queues — Concurrency and parallelism
• branch by abstraction — Architecture and domain modeling
• budget enforcement — LLM performance and cost
• budget tracking — LLM observability and debugging
• buffering — Operating systems and hardware
• Build-buy-partner — Technical strategy and architecture judgment
• build-versus-buy — Principal-level applied AI judgment
• builder — Code design and maintainability
• bulk operations — APIs and integrations
• bulkhead — Reliability and resilience
• Burn-rate alerts — Observability and debugging
• burst capacity — Rate limiting and admission control
• bytecode — Languages and runtimes
• Byzantine faults — Distributed systems

C

• cache avalanche — Caching
• cache coherence — Operating systems and hardware
• cache hit ratio — Caching
• cache invalidation — Frontend and client engineering, LLM performance and cost
• cache lines — Operating systems and hardware
• Cache penetration — Caching
• cache poisoning — Caching
• Cache stampede — Caching
• cache stampede — Distributed key-value stores and Redis
• Cache-aside — Caching
• canary evaluation — Evaluation engineering
• canary release — Testing and delivery
• cancellation — Messaging and durable workflows, Reliability and resilience, Model behavior and API integration, Tools, function calling, and MCP, LLM performance and cost, LLM application UX
• cancellation propagation — Concurrency and parallelism, Agent loop engineering
• CAP — Distributed systems
• capability detection — Model behavior and API integration
• capability negotiation — Tools, function calling, and MCP
• capacity forecasts — Performance and capacity
• captions — Knowledge-base ingestion
• Cardinality — Observability and debugging
• cardinality estimation — Relational databases and SQL
• cascading failure — Reliability and resilience
• catalogs — Data engineering
• causal consistency — Distributed systems
• CDC — Messaging and durable workflows
• CDN — Caching
• certificate chains — Networking and protocols
• certificate rotation — Security and privacy
• cgroups — Operating systems and hardware
• change detection — Knowledge-base ingestion
• channels — Concurrency and parallelism
• Chaos engineering — Reliability and resilience
• checkpointing — Messaging and durable workflows
• Checkpointing — Agent loop engineering
• checkpoints — Data engineering
• Checkpoints — Agent harness and orchestration
• choreography — Messaging and durable workflows
• Chunk overlap — Knowledge-base ingestion
• CI/CD — Testing and delivery
• Circuit breaker — Reliability and resilience
• citation attribution — Retrieval and RAG
• citation correctness — Evaluation engineering
• citation requirements — Prompt engineering
• citation verification — Retrieval and RAG
• Citations — LLM application UX
• clarification — Prompt engineering, Planning, reasoning, and verification
• Clarification UX — LLM application UX
• clean architecture — Architecture and domain modeling
• Client state — Frontend and client engineering
• clock drift — Operating systems and hardware
• clock precision — Operating systems and hardware
• Clock skew — Rate limiting and admission control
• clock skew — Distributed systems
• closed-loop load — Performance and capacity
• Closures — Languages and runtimes
• cluster imbalance — Distributed key-value stores and Redis
• code review — Code design and maintainability
• Code smells — Code design and maintainability
• code splitting — Frontend and client engineering
• cognitive load — Organizational engineering
• coherence — Caching
• Cohesion — Code design and maintainability
• cold starts — Performance and capacity
• collision resolution — Algorithms and data structures
• Columnar storage — Data engineering
• command — Code design and maintainability
• command injection — Security and privacy
• compaction — Nonrelational databases and search, Context engineering
• Compare-and-set — Transactions and concurrency control
• Compare-and-swap — Concurrency and parallelism
• compare-and-swap — Distributed key-value stores and Redis
• compensation — Messaging and durable workflows, Actions and side-effect safety
• Compilation — Languages and runtimes
• completeness — Data engineering
• completion criteria — Agent loop engineering
• completion evidence — Planning, reasoning, and verification
• completion status — Model behavior and API integration
• complexity budgets — Code design and maintainability
• Component evaluation — Evaluation engineering
• component tests — Testing and delivery
• Composite indexes — Relational databases and SQL
• compositing — Frontend and client engineering
• composition — Code design and maintainability
• compression — Networking and protocols, Data engineering, Context engineering
• Concurrency — Concurrency and parallelism
• concurrency limits — Rate limiting and admission control, Agent harness and orchestration
• condition variables — Concurrency and parallelism
• conditional requests — Caching
• confidence — Memory engineering
• confidence calibration — Planning, reasoning, and verification
• confidence intervals — Evaluation engineering
• Configuration management — Infrastructure and cloud
• conflict resolution — Distributed systems, Memory engineering
• Conflicting instructions — Prompt engineering
• confused-deputy attacks — LLM application security
• congestion control — Networking and protocols
• Connection pooling — Networking and protocols
• connection pooling — Relational databases and SQL
• Connection pools — Performance and capacity
• connection pools — Distributed key-value stores and Redis
• connection reuse — Networking and protocols
• Connection timeout — Networking and protocols
• connector permissions — LLM application security
• consensus — Distributed systems
• consensus-backed coordination — Distributed key-value stores and Redis
• consent — Multimodal application integration
• consequential actions — Actions and side-effect safety
• consistency checks — Planning, reasoning, and verification
• Consistent hashing — Algorithms and data structures, Distributed systems
• consistent-prefix reads — Distributed systems
• Constraint checking — Planning, reasoning, and verification
• Constraint preservation — Context engineering
• constraints — Relational databases and SQL, Prompt engineering
• constructive disagreement — Organizational engineering
• consumer groups — Messaging and durable workflows, Distributed key-value stores and Redis
• Consumer lag — Messaging and durable workflows
• consumer-driven contracts — APIs and integrations
• consumers — Messaging and durable workflows
• containers — Infrastructure and cloud
• content negotiation — Networking and protocols
• context budgets — Context engineering
• Context compaction — Agent loop engineering
• Context construction — Context engineering
• context failures — LLM observability and debugging
• context handoff — Context engineering
• context mapping — Architecture and domain modeling
• Context ordering — Context engineering
• context packing — Retrieval and RAG
• context pollution — Context engineering
• context propagation — Observability and debugging
• context reuse — Context engineering, LLM performance and cost
• context selection — Context engineering
• context switches — Operating systems and hardware
• context versions — LLM observability and debugging
• context window — Model behavior and API integration
• continuous batching — LLM performance and cost
• Contract tests — Testing and delivery
• contradictory evidence — Context engineering
• conversation summarization — Context engineering
• Conway’s Law — Organizational engineering
• Cookies — Networking and protocols
• coordinated omission — Performance and capacity
• core dumps — Observability and debugging
• Core Web Vitals — Frontend and client engineering
• coroutines — Concurrency and parallelism
• correction — LLM application UX
• Correlated errors — Planning, reasoning, and verification
• correlation IDs — Observability and debugging
• CORS — Networking and protocols
• cosine similarity — Retrieval and RAG
• cost attribution — LLM observability and debugging
• cost budgets — Agent loop engineering
• Cost per completed task — LLM performance and cost
• Cost per request — Performance and capacity
• cost per tenant — Performance and capacity
• Cost-quality-latency optimization — Principal-level applied AI judgment
• Count-Min Sketch — Algorithms and data structures
• Counters — Observability and debugging
• coupling — Code design and maintainability
• covering indexes — Relational databases and SQL
• CPU affinity — Operating systems and hardware
• CPU caches — Operating systems and hardware
• CPU profiles — Observability and debugging
• CPU-bound work — Concurrency and parallelism
• CQRS — Architecture and domain modeling
• crash recovery — Transactions and concurrency control
• CRDTs — Distributed systems
• Critique-revision loops — Planning, reasoning, and verification
• cross-encoders — Retrieval and RAG
• cross-session consistency — Memory engineering
• Cross-team interfaces — Organizational engineering
• cross-tenant leakage — LLM application security
• CSP — Frontend and client engineering
• CSR — Frontend and client engineering
• CSRF — Security and privacy
• CSSOM — Frontend and client engineering
• CTEs — Relational databases and SQL
• currency — SaaS and business workflows
• cursor pagination — APIs and integrations
• cycle detection — Algorithms and data structures

D

• Data contracts — Data engineering
• data exfiltration — LLM application security
• Data export — SaaS and business workflows
• data lake — Data engineering
• data lineage — Knowledge-base ingestion
• Data minimization — Security and privacy
• data races — Concurrency and parallelism
• Data rights — Principal-level applied AI judgment
• Data warehouse — Data engineering
• database queries — Planning, reasoning, and verification
• dead-letter ingestion — Knowledge-base ingestion
• Dead-letter queues — Messaging and durable workflows
• deadline propagation — Reliability and resilience
• deadlines — Networking and protocols
• Deadlock — Concurrency and parallelism
• Deadlock detection — Transactions and concurrency control
• Decision-making under uncertainty — Technical strategy and architecture judgment
• decoding — LLM performance and cost
• decorator — Code design and maintainability
• deduplication — APIs and integrations, Messaging and durable workflows, SaaS and business workflows, Knowledge-base ingestion, Tools, function calling, and MCP
• Deduplication — Retrieval and RAG, Memory engineering
• defense in depth — Security and privacy
• Delayed jobs — Messaging and durable workflows
• delegation — Agent harness and orchestration, Actions and side-effect safety, Organizational engineering
• deletion — SaaS and business workflows
• deletion propagation — Knowledge-base ingestion, Memory engineering
• Delimiters — Prompt engineering
• Delivery bottlenecks — Organizational engineering
• delivery preferences — SaaS and business workflows
• delivery retries — APIs and integrations
• demonstrated correctness — Planning, reasoning, and verification
• denormalization — Relational databases and SQL
• dense retrieval — Retrieval and RAG
• deoptimization — Languages and runtimes
• dependency cycles — Code design and maintainability
• Dependency graphs — Agent harness and orchestration
• dependency injection — Code design and maintainability
• Dependency inversion — Code design and maintainability
• dependency management — Technical strategy and architecture judgment
• dependency ordering — Tools, function calling, and MCP
• dependency vulnerabilities — Security and privacy
• dependency-aware planning — Planning, reasoning, and verification
• deployments — Infrastructure and cloud
• deprecation — APIs and integrations
• deques — Algorithms and data structures
• Design by contract — Code design and maintainability
• design review — Organizational engineering
• design systems — Frontend and client engineering
• deterministic destruction — Languages and runtimes
• Deterministic graders — Evaluation engineering
• Deterministic routing — Agent harness and orchestration
• Deterministic tests — Testing and delivery
• deterministic workflows — Principal-level applied AI judgment
• developer experience — Organizational engineering
• developer instructions — Prompt engineering
• DFS — Algorithms and data structures
• diarization — Multimodal application integration
• difference arrays — Algorithms and data structures
• differential testing — Testing and delivery
• dimensional modeling — Data engineering
• Direct prompt injection — LLM application security
• Dirty read — Transactions and concurrency control
• Disaster recovery — Reliability and resilience
• discriminated unions — Languages and runtimes
• distributed cache — Caching
• Distributed counters — Rate limiting and admission control
• Distributed key-value store — Distributed key-value stores and Redis
• distributed locks — Distributed systems
• distributed tracing — Observability and debugging
• diversity — Retrieval and RAG
• divide and conquer — Algorithms and data structures
• DNS — Networking and protocols
• document databases — Nonrelational databases and search
• document hierarchy — Knowledge-base ingestion
• Document IDs — Knowledge-base ingestion
• document inputs — Multimodal application integration
• Document parsing — Knowledge-base ingestion
• dogpile effect — Caching
• DOM — Frontend and client engineering
• domain errors — Code design and maintainability
• Domain events — Architecture and domain modeling
• domain services — Architecture and domain modeling
• downsampling — Nonrelational databases and search
• Draft state — LLM application UX
• drift detection — Infrastructure and cloud
• DRY — Code design and maintainability
• dry runs — Tools, function calling, and MCP
• duplicate prevention — Actions and side-effect safety
• durability — Reliability and resilience
• durable execution — Messaging and durable workflows
• durable state — Agent loop engineering
• Durable workflows — Agent harness and orchestration
• dynamic programming — Algorithms and data structures
• dynamic typing — Languages and runtimes

E

• Editable plans — LLM application UX
• effective dates — SaaS and business workflows
• egress costs — Infrastructure and cloud
• ELT — Data engineering
• Embedding compatibility — Retrieval and RAG
• Embedding migrations — Retrieval and RAG
• embeddings — Retrieval and RAG
• enabling teams — Organizational engineering
• encapsulation — Code design and maintainability
• encryption at rest — Security and privacy
• end-to-end evaluation — Evaluation engineering
• end-to-end latency — LLM observability and debugging
• end-to-end tests — Testing and delivery
• Enforceable governance — Principal-level applied AI judgment
• Engineering standards — Organizational engineering
• Entities — Architecture and domain modeling
• Entitlements — SaaS and business workflows
• envelope encryption — Security and privacy
• environment parity — Infrastructure and cloud
• Episodic memory — Memory engineering
• epoll — Operating systems and hardware
• Error boundaries — Agent harness and orchestration
• error budget — Reliability and resilience
• Error taxonomies — LLM observability and debugging
• Error taxonomy — Code design and maintainability
• error values — Languages and runtimes
• escalation — Model behavior and API integration, LLM performance and cost
• ETag — Caching
• etcd — Distributed key-value stores and Redis
• ETL — Data engineering
• evaluation coverage — Evaluation engineering
• Evaluation coverage — Principal-level applied AI judgment
• evaluation flywheel — Prompt engineering
• Event loop — Frontend and client engineering
• event loops — Concurrency and parallelism
• event sourcing — Architecture and domain modeling
• event streams — Messaging and durable workflows
• Event time — Data engineering
• event versioning — Messaging and durable workflows
• Event-driven architecture — Architecture and domain modeling
• event-driven execution — Agent harness and orchestration
• eventual consistency — Distributed systems
• eviction — Caching
• eviction policy — Distributed key-value stores and Redis
• evidence gathering — Planning, reasoning, and verification
• evolutionary architecture — Architecture and domain modeling
• exactly-once semantics — Messaging and durable workflows
• example selection — Prompt engineering
• exception boundaries — Languages and runtimes, Code design and maintainability
• Exceptions — Languages and runtimes
• exceptions — Organizational engineering
• Excessive agency — LLM application security
• executable checks — Planning, reasoning, and verification
• executed state — LLM application UX
• execution receipts — Actions and side-effect safety
• Execution traces — LLM observability and debugging
• executor saturation — Concurrency and parallelism
• exemplars — Observability and debugging
• exhaustive matching — Languages and runtimes
• expiration — Caching, Knowledge-base ingestion
• expiry — Memory engineering
• EXPLAIN — Relational databases and SQL
• Explicit memories — Memory engineering
• Explicit task state — Agent loop engineering
• Exponential backoff — Messaging and durable workflows
• expression indexes — Relational databases and SQL
• external verification — Planning, reasoning, and verification

F

• facade — Code design and maintainability
• faceting — Nonrelational databases and search
• factory — Code design and maintainability
• factual correctness — Model behavior and API integration
• fail-closed — Rate limiting and admission control
• fail-open — Rate limiting and admission control
• failback — Reliability and resilience
• Failed-ingestion recovery — Knowledge-base ingestion
• Failover — Reliability and resilience
• failover — Distributed key-value stores and Redis
• failure containment — Principal-level applied AI judgment
• failure detection — Distributed systems
• faithfulness — Retrieval and RAG
• fakes — Testing and delivery
• fallback — Model behavior and API integration
• false sharing — Operating systems and hardware
• fan-out amplification — Performance and capacity
• Fault domains — Reliability and resilience
• fault injection — Reliability and resilience
• fault tolerance — Reliability and resilience
• Feature flags — Testing and delivery
• fencing tokens — Distributed systems, Distributed key-value stores and Redis
• Fenwick trees — Algorithms and data structures
• few-shot prompting — Prompt engineering
• FFI — Languages and runtimes
• FIFO — Caching
• File descriptors — Operating systems and hardware
• Filesystems — Operating systems and hardware
• Filtering — APIs and integrations
• final responses — Model behavior and API integration
• FinOps — Infrastructure and cloud
• Fixed-size chunking — Knowledge-base ingestion
• Fixed-window counter — Rate limiting and admission control
• flaky tests — Testing and delivery
• flame graphs — Observability and debugging
• flow control — Networking and protocols
• Forgetting — Memory engineering
• formatting constraints — Prompt engineering
• Freshness — Data engineering, Knowledge-base ingestion
• freshness — Context engineering
• fsync — Operating systems and hardware
• full-text search — Nonrelational databases and search
• Function calling — Tools, function calling, and MCP
• functional dependencies — Relational databases and SQL
• functional requirements — Technical strategy and architecture judgment
• futures — Concurrency and parallelism
• fuzzing — Testing and delivery
• fuzzy matching — Nonrelational databases and search

G

• garbage collection — Languages and runtimes
• gauges — Observability and debugging
• GC pauses — Performance and capacity
• GCRA — Rate limiting and admission control
• generated columns — Relational databases and SQL
• generated command injection — LLM application security
• generator-verifier pattern — Planning, reasoning, and verification
• Generics — Languages and runtimes
• GitHub flow — Testing and delivery
• global indexes — Nonrelational databases and search
• golden answers — Evaluation engineering
• golden datasets — Evaluation engineering
• golden signals — Observability and debugging
• gossip — Distributed systems
• graceful degradation — Reliability and resilience
• Graceful degradation — LLM performance and cost
• graph databases — Nonrelational databases and search
• graph query languages — Nonrelational databases and search
• Graph traversal — Nonrelational databases and search
• graph-assisted retrieval — Retrieval and RAG
• GraphQL — APIs and integrations
• greedy algorithms — Algorithms and data structures
• Groundedness — Retrieval and RAG
• groundedness — Evaluation engineering
• Grounding instructions — Prompt engineering
• gRPC — APIs and integrations

H

• handoff — Agent loop engineering
• handoff traces — LLM observability and debugging
• Handoffs — Agent harness and orchestration
• happens-before — Concurrency and parallelism
• hash join — Relational databases and SQL
• Hash maps — Algorithms and data structures
• hash sets — Algorithms and data structures
• hash slots — Distributed key-value stores and Redis
• hash tags — Distributed key-value stores and Redis
• hashes — Distributed key-value stores and Redis
• Head sampling — Observability and debugging
• head-of-line blocking — Networking and protocols
• headers — Networking and protocols
• headroom — Performance and capacity
• heap allocation — Languages and runtimes
• heap profiles — Observability and debugging
• Heaps — Algorithms and data structures
• hermetic builds — Testing and delivery
• hexagonal architecture — Architecture and domain modeling
• hierarchical quotas — Rate limiting and admission control
• hierarchical retrieval — Retrieval and RAG
• hinted handoff — Distributed systems
• histograms — Observability and debugging
• HNSW — Retrieval and RAG
• hopping windows — Data engineering
• horizontal scaling — Performance and capacity
• hostname verification — Networking and protocols
• hot keys — Rate limiting and admission control, Caching
• Hot keys — Distributed key-value stores and Redis
• hot partitions — Distributed systems
• HTTP 429 — Rate limiting and admission control
• HTTP methods — Networking and protocols
• HTTP/1.1 — Networking and protocols
• HTTP/2 — Networking and protocols
• HTTP/3 — Networking and protocols
• human accountability — Principal-level applied AI judgment
• human annotation — Evaluation engineering
• human handoff — LLM application UX
• Human-in-the-loop — Actions and side-effect safety
• hybrid search — Retrieval and RAG
• hydration — Frontend and client engineering
• HyperLogLog — Algorithms and data structures, Distributed key-value stores and Redis
• Hypothesis generation — Planning, reasoning, and verification
• hypothesis testing — Observability and debugging

I

• I/O-bound work — Concurrency and parallelism
• IAM — Infrastructure and cloud
• idempotency — APIs and integrations
• Idempotency — Tools, function calling, and MCP
• idempotency keys — APIs and integrations
• Idempotency keys — Actions and side-effect safety
• Idempotent consumers — Messaging and durable workflows
• idle timeout — Networking and protocols
• IDOR — Security and privacy
• image grounding — Multimodal application integration
• Image inputs — Multimodal application integration
• image layers — Infrastructure and cloud
• images — Knowledge-base ingestion
• immutability — Languages and runtimes
• immutable financial records — SaaS and business workflows
• immutable infrastructure — Infrastructure and cloud
• inbox pattern — Messaging and durable workflows
• incident leadership — Organizational engineering
• incident response — Reliability and resilience
• incremental ingestion — Knowledge-base ingestion
• incremental processing — Data engineering
• independent verification — Planning, reasoning, and verification
• index bloat — Relational databases and SQL
• index column order — Relational databases and SQL
• index scan — Relational databases and SQL
• index tuning — Retrieval and RAG
• IndexedDB — Frontend and client engineering
• indirect prompt injection — LLM application security
• inference budgets — Model behavior and API integration
• inferred memories — Memory engineering
• Influence without authority — Organizational engineering
• information hiding — Code design and maintainability
• Infrastructure as code — Infrastructure and cloud
• ingestion validation — Knowledge-base ingestion
• ingress — Infrastructure and cloud
• inheritance — Code design and maintainability
• input token budget — Model behavior and API integration
• Input token cost — LLM performance and cost
• insecure deserialization — Security and privacy
• Instruction adherence — Evaluation engineering
• instruction following — Model behavior and API integration
• Instruction hierarchy — Model behavior and API integration
• instruction precedence — Prompt engineering
• instruction-data separation — Prompt engineering
• Instruction-data separation — LLM application security
• insufficient evidence — Retrieval and RAG
• integration events — Architecture and domain modeling
• integration tests — Testing and delivery
• inter-rater agreement — Evaluation engineering
• internationalization — Frontend and client engineering
• interpretation — Languages and runtimes
• interprocess communication — Operating systems and hardware
• Interruptibility — Agent loop engineering
• interruption handling — Multimodal application integration
• interrupts — Operating systems and hardware
• interval trees — Algorithms and data structures
• invalidation — Caching
• invariants — Code design and maintainability
• Inverted index — Nonrelational databases and search
• IP — Networking and protocols
• irreversible decisions — Technical strategy and architecture judgment
• isolated state — Agent harness and orchestration
• IVF — Retrieval and RAG

J

• Jailbreaks — LLM application security
• JIT — Languages and runtimes
• jitter — Networking and protocols, Messaging and durable workflows
• job handles — APIs and integrations
• Joins — Relational databases and SQL
• journaling — Operating systems and hardware
• JSON schemas — Prompt engineering, Tools, function calling, and MCP
• judge bias — Evaluation engineering
• judge calibration — Evaluation engineering
• just-in-time retrieval — Context engineering
• JWT — Security and privacy

K

• keepalive — Networking and protocols
• key derivation — Security and privacy
• key rotation — Security and privacy
• Key-value stores — Nonrelational databases and search
• keyboard navigation — Frontend and client engineering
• Keys — Relational databases and SQL
• keyset pagination — APIs and integrations
• keyword search — Retrieval and RAG
• KISS — Code design and maintainability
• knowledge cutoff — Model behavior and API integration
• kqueue — Operating systems and hardware
• KV cache — LLM performance and cost

L

• lakehouse — Data engineering
• Lamport clocks — Distributed systems
• last-write-wins — Distributed systems
• late events — Data engineering
• Latency — Performance and capacity
• Latency budgets — LLM performance and cost
• launch criteria — Principal-level applied AI judgment
• Layered architecture — Architecture and domain modeling
• layout — Frontend and client engineering
• layout extraction — Knowledge-base ingestion
• layout understanding — Multimodal application integration
• lazy expiration — Distributed key-value stores and Redis
• lazy loading — Frontend and client engineering
• leader election — Distributed systems
• Leader-follower — Distributed systems
• leaderless replication — Distributed systems
• Leaky bucket — Rate limiting and admission control
• learning culture — Organizational engineering
• lease expiry — Distributed key-value stores and Redis
• leases — Distributed systems, Distributed key-value stores and Redis
• Least privilege — Security and privacy
• least privilege — Actions and side-effect safety
• lexical scope — Languages and runtimes
• LFU — Caching
• lifetimes — Languages and runtimes
• lineage — Data engineering
• Linearizability — Distributed systems
• Linearizable KV reads — Distributed key-value stores and Redis
• linked lists — Algorithms and data structures
• lists — Distributed key-value stores and Redis
• Little’s Law — Performance and capacity
• livelock — Concurrency and parallelism
• Liveness — Reliability and resilience
• load balancing — Networking and protocols
• load factor — Algorithms and data structures
• load shedding — Rate limiting and admission control
• Load testing — Performance and capacity
• Local cache — Caching
• local indexes — Nonrelational databases and search
• local storage — Frontend and client engineering
• locality — Operating systems and hardware
• localization — Frontend and client engineering
• lock ordering — Transactions and concurrency control
• lock profiles — Observability and debugging
• lock safety assumptions — Distributed key-value stores and Redis
• lock timeout — Transactions and concurrency control
• Lock-free — Concurrency and parallelism
• Logs — Observability and debugging
• long polling — Networking and protocols
• long-running jobs — Agent harness and orchestration
• Long-running operations — APIs and integrations
• loop counts — LLM observability and debugging
• Loop efficiency — Evaluation engineering
• Lost update — Transactions and concurrency control
• Lost-in-the-middle — Context engineering
• LRU — Caching
• LSM trees — Algorithms and data structures
• Lua scripts — Distributed key-value stores and Redis

M

• maintainability — Technical strategy and architecture judgment
• Malicious URLs — LLM application security
• Managed databases — Infrastructure and cloud
• managed queues — Infrastructure and cloud
• materialized views — Relational databases and SQL
• maximal marginal relevance — Retrieval and RAG
• maximum steps — Agent loop engineering
• maxmemory — Distributed key-value stores and Redis
• MCP authorization — Tools, function calling, and MCP
• MCP prompts — Tools, function calling, and MCP
• MCP resources — Tools, function calling, and MCP
• MCP tools — Tools, function calling, and MCP
• MCP transports — Tools, function calling, and MCP
• measurable constraints — Technical strategy and architecture judgment
• measured outcomes — Prompt engineering
• media retention — Multimodal application integration
• memoization — Frontend and client engineering
• memory barriers — Concurrency and parallelism
• Memory extraction — Memory engineering
• Memory leaks — Languages and runtimes
• memory poisoning — Memory engineering, LLM application security
• memory pressure — Performance and capacity
• mentoring — Organizational engineering
• merge join — Relational databases and SQL
• message passing — Concurrency and parallelism
• message-driven architecture — Architecture and domain modeling
• Metadata extraction — Knowledge-base ingestion
• Metadata filtering — Retrieval and RAG
• metaprogramming — Languages and runtimes
• metrics — Observability and debugging
• microservices — Architecture and domain modeling
• microtasks — Frontend and client engineering
• Migration sequencing — Technical strategy and architecture judgment
• minimum spanning trees — Algorithms and data structures
• mmap — Operating systems and hardware
• Mocks — Testing and delivery
• modalities — Model behavior and API integration
• Model capabilities — Model behavior and API integration
• Model confidence — Model behavior and API integration
• model failures — LLM observability and debugging
• model graders — Evaluation engineering
• model migrations — Model behavior and API integration
• Model routing — LLM performance and cost
• Model selection — Model behavior and API integration
• model spans — LLM observability and debugging
• model upgrade strategy — Principal-level applied AI judgment
• model-selected routing — Agent harness and orchestration
• modular monolith — Architecture and domain modeling
• Money precision — SaaS and business workflows
• Monolith — Architecture and domain modeling
• monotonic clocks — Operating systems and hardware
• monotonic reads — Distributed systems
• MOVED — Distributed key-value stores and Redis
• MRR — Retrieval and RAG
• multi-leader — Distributed systems
• multi-query retrieval — Retrieval and RAG
• multi-region — Infrastructure and cloud
• Multi-tenancy — SaaS and business workflows
• Multi-zone — Infrastructure and cloud
• MULTI/EXEC — Distributed key-value stores and Redis
• multilevel cache — Caching
• Multimodal prompt injection — Multimodal application integration
• Mutation testing — Testing and delivery
• Mutexes — Concurrency and parallelism
• mutual TLS — Networking and protocols
• MVCC — Transactions and concurrency control

N

• N+1 queries — Relational databases and SQL
• Namespaces — Operating systems and hardware
• NAT — Networking and protocols
• nDCG — Retrieval and RAG
• negative caching — Networking and protocols, Caching
• negative examples — Prompt engineering
• negotiation — Organizational engineering
• nested-loop join — Relational databases and SQL
• network egress controls — LLM application security
• network partitions — Distributed systems, Distributed key-value stores and Redis
• next-action selection — Agent loop engineering
• No-progress termination — Agent loop engineering
• No-result behavior — Retrieval and RAG
• noisy-neighbor protection — SaaS and business workflows
• nominal typing — Languages and runtimes
• nonblocking I/O — Operating systems and hardware
• nondeterminism — Model behavior and API integration
• Nonfunctional requirements — Technical strategy and architecture judgment
• nonrepeatable read — Transactions and concurrency control
• Normalization — Relational databases and SQL, Knowledge-base ingestion
• normalization — Retrieval and RAG
• Notifications — SaaS and business workflows
• nullable types — Languages and runtimes
• NUMA — Operating systems and hardware

O

• OAuth 2.0 — Security and privacy
• object pooling — Languages and runtimes
• object storage — Nonrelational databases and search, Infrastructure and cloud
• objective preservation — Agent loop engineering
• objectives — Agent loop engineering
• Observe-decide-act loop — Agent loop engineering
• Observer — Code design and maintainability
• OCR — Knowledge-base ingestion
• OCR quality — Multimodal application integration
• Offline synchronization — Frontend and client engineering
• Offset pagination — APIs and integrations
• offsets — Messaging and durable workflows
• OLAP — Data engineering
• OLTP — Data engineering
• On-call — Reliability and resilience
• Online experiments — Evaluation engineering
• online migrations — Relational databases and SQL
• OOM termination — Operating systems and hardware
• Open-loop load — Performance and capacity
• OpenAPI — APIs and integrations
• OpenID Connect — Security and privacy
• Operability — Technical strategy and architecture judgment
• operational ownership — Principal-level applied AI judgment
• Optimistic concurrency — Transactions and concurrency control
• optimistic concurrency — Actions and side-effect safety
• Optimistic updates — Frontend and client engineering
• ORC — Data engineering
• orchestration — Messaging and durable workflows
• Order state machines — SaaS and business workflows
• ordering — Concurrency and parallelism
• original evidence — Memory engineering
• outcome metrics — Organizational engineering
• Output contracts — Prompt engineering
• output token budget — Model behavior and API integration
• output token cost — LLM performance and cost
• output validation — LLM application security
• overconstraint — Prompt engineering
• overload protection — Reliability and resilience
• ownership — Languages and runtimes
• ownership boundaries — Organizational engineering

P

• p50 — Observability and debugging
• p95 — Observability and debugging
• p99 — Observability and debugging
• PACELC — Distributed systems
• page faults — Operating systems and hardware
• page tables — Operating systems and hardware
• pagination — Tools, function calling, and MCP
• paint — Frontend and client engineering
• parallel execution — Agent harness and orchestration
• Parallel tool calls — Tools, function calling, and MCP
• parallelism — Concurrency and parallelism, Performance and capacity
• parallelization — LLM performance and cost
• parent-child chunks — Knowledge-base ingestion
• Parent-document retrieval — Retrieval and RAG
• Parquet — Data engineering
• partial completion — Agent loop engineering
• Partial failure — Distributed systems
• partial indexes — Relational databases and SQL
• partial responses — Model behavior and API integration
• partial results — LLM application UX
• partial updates — APIs and integrations
• Partition keys — Nonrelational databases and search
• Partitioning — Relational databases and SQL
• partitions — Messaging and durable workflows
• Password hashing — Security and privacy
• path traversal — Security and privacy
• Paxos — Distributed systems
• Payment idempotency — SaaS and business workflows
• payment state machines — SaaS and business workflows
• pending entries — Distributed key-value stores and Redis
• Per-IP limits — Rate limiting and admission control
• per-tenant limits — Rate limiting and admission control
• per-user limits — Rate limiting and admission control
• perceived latency — LLM application UX
• performance budgets — Frontend and client engineering
• permanent errors — Tools, function calling, and MCP
• permission filtering — Retrieval and RAG
• Permission scope — Actions and side-effect safety
• persistence recovery — Distributed key-value stores and Redis
• persistent memory — Memory engineering
• persistent volumes — Infrastructure and cloud
• pessimistic concurrency — Transactions and concurrency control
• phantom read — Transactions and concurrency control
• pipelining — Performance and capacity
• pipes — Operating systems and hardware
• PKCE — Security and privacy
• placement — Context engineering
• Planner-executor — Agent harness and orchestration
• platform strategy — Technical strategy and architecture judgment
• Platform teams — Organizational engineering
• Plausibility — Planning, reasoning, and verification
• Pods — Infrastructure and cloud
• poison messages — Messaging and durable workflows
• policy enforcement — LLM application security
• policy-as-code — Principal-level applied AI judgment
• polling — Networking and protocols
• portability — Principal-level applied AI judgment
• portfolio risk — Technical strategy and architecture judgment
• ports and adapters — Architecture and domain modeling
• postconditions — Code design and maintainability
• postmortems — Reliability and resilience
• precision@k — Retrieval and RAG
• preconditions — Code design and maintainability
• predicate locks — Transactions and concurrency control
• Prefill — LLM performance and cost
• prefix sums — Algorithms and data structures
• prepared statements — Relational databases and SQL
• preview-before-action — LLM application UX
• previews — Tools, function calling, and MCP
• priority inversion — Concurrency and parallelism
• priority queues — Algorithms and data structures
• privilege escalation — LLM application security
• probabilistic decisions — Principal-level applied AI judgment
• probabilistic early refresh — Caching
• Problem framing — Technical strategy and architecture judgment
• procedural memory — Memory engineering
• Processes — Operating systems and hardware
• processes — Concurrency and parallelism
• processing time — Data engineering
• Producers — Messaging and durable workflows
• product quantization — Retrieval and RAG
• product teams — Organizational engineering
• production examples — Evaluation engineering
• production-to-eval datasets — LLM observability and debugging
• profiles — Observability and debugging
• Progress detection — Agent loop engineering
• progress updates — LLM application UX
• progressive disclosure — Context engineering
• Progressive enhancement — Frontend and client engineering
• projections — Architecture and domain modeling
• promises — Concurrency and parallelism
• prompt brittleness — Prompt engineering
• Prompt caching — Context engineering, LLM performance and cost
• prompt chaining — Prompt engineering
• Prompt failures — LLM observability and debugging
• Prompt optimization — Prompt engineering
• prompt regression tests — Prompt engineering
• Prompt templates — Prompt engineering
• prompt versioning — Prompt engineering
• Prompt versions — LLM observability and debugging
• property-based tests — Testing and delivery
• Protocol Buffers — APIs and integrations
• protocol versioning — Tools, function calling, and MCP
• provenance — Context engineering, Principal-level applied AI judgment
• Provenance — Memory engineering
• provider compatibility — Model behavior and API integration
• Provider quotas — LLM performance and cost
• provisioning — SaaS and business workflows
• proxies — Networking and protocols
• pseudonymization — Security and privacy
• Public interfaces — Code design and maintainability
• publish-subscribe — Messaging and durable workflows
• Pure functions — Code design and maintainability

Q

• quality attributes — Technical strategy and architecture judgment
• quality-adjusted cost — LLM performance and cost
• Quality-latency-cost tradeoffs — Evaluation engineering
• quantization — LLM performance and cost
• query decomposition — Retrieval and RAG
• query expansion — Retrieval and RAG
• Query planner — Relational databases and SQL
• Query rewriting — Retrieval and RAG
• query tracing — Observability and debugging
• queue growth — Messaging and durable workflows
• queue stability — Performance and capacity
• queueing theory — Performance and capacity
• queues — Algorithms and data structures
• Queues — Messaging and durable workflows
• QUIC — Networking and protocols
• quorum reads — Distributed systems
• quorum writes — Distributed systems
• quota leasing — Rate limiting and admission control
• quotas — Model behavior and API integration

R

• Race conditions — Concurrency and parallelism
• Raft — Distributed systems
• RAG — Retrieval and RAG
• rate limits — Model behavior and API integration
• RBAC — Security and privacy
• RDB snapshots — Distributed key-value stores and Redis
• re-identification — Security and privacy
• Read amplification — Nonrelational databases and search
• Read committed — Transactions and concurrency control
• read repair — Distributed systems
• read timeout — Networking and protocols
• Read tools — Tools, function calling, and MCP
• read-after-write verification — Actions and side-effect safety
• Read-only actions — Actions and side-effect safety
• read-through — Caching
• read-write locks — Concurrency and parallelism
• Read-your-writes — Distributed systems
• readiness — Reliability and resilience
• real-world coverage — Principal-level applied AI judgment
• Realtime sessions — Multimodal application integration
• reasoning budgets — LLM performance and cost
• reasoning effort — Model behavior and API integration
• ReBAC — Security and privacy
• rebalancing — Distributed systems
• Recall@k — Retrieval and RAG
• reciprocal rank fusion — Retrieval and RAG
• reconciliation — Data engineering, Actions and side-effect safety
• recoverable errors — LLM application UX
• recoverable failure — Agent loop engineering
• recovery policy — Agent loop engineering
• recovery success — Evaluation engineering
• Recursion — Algorithms and data structures
• recursive chunking — Knowledge-base ingestion
• recursive queries — Relational databases and SQL
• recursive resolution — Networking and protocols
• RED method — Observability and debugging
• redelivery — Messaging and durable workflows
• Redis — Distributed key-value stores and Redis
• Redis Cluster — Distributed key-value stores and Redis
• Redis Functions — Distributed key-value stores and Redis
• Redis locks — Distributed key-value stores and Redis
• Redis Lua — Rate limiting and admission control
• Redis pipelining — Distributed key-value stores and Redis
• Redis Pub/Sub — Distributed key-value stores and Redis
• Redis replication — Distributed key-value stores and Redis
• Redis Sentinel — Distributed key-value stores and Redis
• Redis Streams — Distributed key-value stores and Redis
• Redis strings — Distributed key-value stores and Redis
• Redis TTL — Distributed key-value stores and Redis
• Redlock — Distributed key-value stores and Redis
• redundancy — Reliability and resilience
• refactoring — Code design and maintainability
• reference counting — Languages and runtimes
• reference semantics — Languages and runtimes
• referential integrity — Relational databases and SQL
• referential transparency — Code design and maintainability
• refill rate — Rate limiting and admission control
• reflection — Languages and runtimes
• refresh tokens — Security and privacy
• refusals — Model behavior and API integration
• regional evacuation — Reliability and resilience
• registries — Infrastructure and cloud
• regression suites — Evaluation engineering
• reindexing — Retrieval and RAG
• release gates — Testing and delivery
• release observability — Testing and delivery
• relevance — Context engineering, Memory engineering
• reliability — Reliability and resilience
• render profiling — Frontend and client engineering
• rendezvous hashing — Algorithms and data structures
• repeatable read — Transactions and concurrency control
• repeated actions — LLM observability and debugging
• Repeated runs — Evaluation engineering
• repeated-action detection — Agent loop engineering
• Replanning — Agent loop engineering
• replanning — Planning, reasoning, and verification
• replay — Architecture and domain modeling, Agent harness and orchestration
• Replay — Messaging and durable workflows
• replay protection — APIs and integrations
• Replication — Distributed systems
• replication lag — Distributed systems, Distributed key-value stores and Redis
• Repositories — Architecture and domain modeling
• Representative datasets — Evaluation engineering
• reproducibility limits — Model behavior and API integration
• reproducible builds — Testing and delivery
• request coalescing — Caching
• request identity — Actions and side-effect safety
• Requests and limits — Infrastructure and cloud
• requirements discovery — Technical strategy and architecture judgment
• reranking — Retrieval and RAG
• reserved capacity — Infrastructure and cloud
• reservoir sampling — Algorithms and data structures
• resharding — Distributed key-value stores and Redis
• resource cleanup — Languages and runtimes
• resource isolation — Agent harness and orchestration
• resource limits — Operating systems and hardware
• Resource modeling — APIs and integrations
• resource tagging — Infrastructure and cloud
• Response caching — LLM performance and cost
• responsive design — Frontend and client engineering
• REST — APIs and integrations
• restore drills — Reliability and resilience
• result summarization — Context engineering
• result-size limits — Tools, function calling, and MCP
• resumability — Agent loop engineering
• Retention — Nonrelational databases and search
• retention — Messaging and durable workflows, SaaS and business workflows, Principal-level applied AI judgment
• retransmission — Networking and protocols
• retries — Model behavior and API integration
• retrieval — Memory engineering
• retrieval failures — LLM observability and debugging
• retrieval freshness — Retrieval and RAG
• retrieval latency — LLM performance and cost
• retrieval poisoning — Retrieval and RAG
• Retrieval poisoning — LLM application security
• retrieval relevance — Evaluation engineering
• retrieved evidence — Model behavior and API integration, Context engineering
• retrieved-document IDs — LLM observability and debugging
• Retry amplification — Reliability and resilience
• retry amplification — LLM performance and cost
• retry budgets — Messaging and durable workflows
• Retry policy — Agent loop engineering
• Retry-After — Rate limiting and admission control
• retry-safe operations — Transactions and concurrency control
• retryable errors — Tools, function calling, and MCP
• reusable prefixes — Context engineering, LLM performance and cost
• reversible decisions — Technical strategy and architecture judgment
• revocation — Security and privacy
• RFC review — Organizational engineering
• RFCs — Architecture and domain modeling
• ring buffers — Algorithms and data structures
• risk communication — Organizational engineering
• risk-based testing — Testing and delivery
• roll-forward — Testing and delivery, Actions and side-effect safety
• Rollback — Testing and delivery
• rollback — Frontend and client engineering, Actions and side-effect safety
• rolling deployment — Testing and delivery
• rollups — Nonrelational databases and search
• rounding — SaaS and business workflows
• router patterns — Agent harness and orchestration
• routing — Infrastructure and cloud, Model behavior and API integration
• Row locks — Transactions and concurrency control
• row-level security — Security and privacy
• RPC — APIs and integrations
• RPO — Reliability and resilience
• RTO — Reliability and resilience
• Rubrics — Evaluation engineering
• runbooks — Reliability and resilience
• runtime policy enforcement — Agent harness and orchestration

S

• Safe methods — APIs and integrations
• Sagas — Messaging and durable workflows
• salts — Security and privacy
• same-origin policy — Networking and protocols
• sampling — Observability and debugging
• Sampling — Model behavior and API integration
• Sandbox isolation — LLM application security
• sandboxing — Security and privacy
• sargability — Relational databases and SQL
• saturation — Performance and capacity
• SBOM — Security and privacy
• scalability limits — Performance and capacity
• scheduled jobs — Messaging and durable workflows
• scheduling — Operating systems and hardware, Infrastructure and cloud
• schema compatibility — Testing and delivery
• schema evolution — APIs and integrations, Data engineering
• schema registry — Messaging and durable workflows
• schema validation — APIs and integrations
• scoped credentials — Tools, function calling, and MCP
• Secondary indexes — Nonrelational databases and search
• secret injection — Infrastructure and cloud
• Secret leakage — LLM application security
• Secrets management — Security and privacy
• security groups — Infrastructure and cloud
• Segment trees — Algorithms and data structures
• Selective history retrieval — Context engineering
• Selectivity — Relational databases and SQL
• semantic caching — LLM performance and cost
• semantic chunking — Knowledge-base ingestion
• semantic HTML — Frontend and client engineering
• semantic memory — Memory engineering
• semaphores — Concurrency and parallelism
• Sensitive-data redaction — LLM observability and debugging
• separate databases — SaaS and business workflows
• separate schemas — SaaS and business workflows
• separation of concerns — Code design and maintainability
• sequential consistency — Distributed systems
• sequential execution — Agent harness and orchestration
• Sequential scan — Relational databases and SQL
• serializability — Distributed systems
• serializable — Transactions and concurrency control
• serializable snapshot isolation — Transactions and concurrency control
• serialization anomaly — Transactions and concurrency control
• serialization compatibility — APIs and integrations
• server state — Frontend and client engineering
• serverless — Architecture and domain modeling
• service discovery — Infrastructure and cloud
• Service mesh — Infrastructure and cloud
• service ownership — Organizational engineering
• service workers — Frontend and client engineering
• service-oriented architecture — Architecture and domain modeling
• services — Infrastructure and cloud
• session continuation — Context engineering
• Session continuity — LLM application UX
• session lifecycle — Tools, function calling, and MCP, Agent harness and orchestration
• session memory — Memory engineering
• session recovery — Multimodal application integration
• session storage — Frontend and client engineering
• session windows — Data engineering
• sessions — Networking and protocols
• Sessions — Security and privacy
• sets — Distributed key-value stores and Redis
• shadow runs — Evaluation engineering
• sharding — Distributed systems
• Shared AI platform — Principal-level applied AI judgment
• Shared database — SaaS and business workflows
• shared memory — Operating systems and hardware
• shared state — Agent harness and orchestration
• short-lived credentials — Infrastructure and cloud
• Shortest paths — Algorithms and data structures
• side effects — Code design and maintainability
• sidecars — Infrastructure and cloud
• signals — Operating systems and hardware
• SIMD — Operating systems and hardware
• single-flight — Caching
• skip lists — Algorithms and data structures
• SLA — Reliability and resilience
• SLI — Reliability and resilience
• slice analysis — Evaluation engineering
• sliding window — Algorithms and data structures
• sliding windows — Data engineering
• Sliding-window counter — Rate limiting and admission control
• Sliding-window log — Rate limiting and admission control
• SLO — Reliability and resilience
• Slowly changing dimensions — Data engineering
• small-model first pass — LLM performance and cost
• snapshot isolation — Transactions and concurrency control
• snapshots — Architecture and domain modeling
• snowflake schema — Data engineering
• soak testing — Performance and capacity
• sockets — Operating systems and hardware
• SOLID — Code design and maintainability
• sort keys — Nonrelational databases and search
• sorted sets — Distributed key-value stores and Redis
• sorting — APIs and integrations
• sorting stability — Algorithms and data structures
• source attribution — Context engineering
• Source connectors — Knowledge-base ingestion
• source inspection — LLM application UX
• source permissions — Knowledge-base ingestion
• source URLs — Knowledge-base ingestion
• source verification — Planning, reasoning, and verification
• Spans — Observability and debugging
• sparse indexes — Nonrelational databases and search
• sparse retrieval — Retrieval and RAG
• Speech recognition — Multimodal application integration
• speech-to-speech — Multimodal application integration
• spike testing — Performance and capacity
• Split-brain — Distributed systems
• sponsorship — Organizational engineering
• spot capacity — Infrastructure and cloud
• SQL injection — Security and privacy
• SQL window functions — Relational databases and SQL
• SSE — Networking and protocols
• SSG — Frontend and client engineering
• SSO — SaaS and business workflows
• SSR — Frontend and client engineering
• SSRF — Security and privacy, LLM application security
• stable chunk IDs — Knowledge-base ingestion
• Stack allocation — Languages and runtimes
• stacks — Algorithms and data structures
• staged prompting — Prompt engineering
• Stakeholder alignment — Organizational engineering
• stale approvals — Actions and side-effect safety
• stale context — Context engineering
• stale-if-error — Caching
• Stale-while-revalidate — Caching
• staleness — Memory engineering
• Standardization — Technical strategy and architecture judgment
• Star schema — Data engineering
• startup checks — Reliability and resilience
• starvation — Concurrency and parallelism
• state machine — Agent harness and orchestration
• state pattern — Code design and maintainability
• Stateful processing — Data engineering
• StatefulSets — Infrastructure and cloud
• static analysis — Code design and maintainability
• Static typing — Languages and runtimes
• statistics — Relational databases and SQL
• status codes — Networking and protocols
• stemming — Nonrelational databases and search
• stochastic variation — Evaluation engineering
• Stop conditions — Agent loop engineering
• stop sequences — Model behavior and API integration
• stragglers — Performance and capacity
• Strangler migration — Architecture and domain modeling
• Strategy — Code design and maintainability
• stream joins — Data engineering
• stream processing — Data engineering
• streaming — LLM performance and cost
• Streaming events — Model behavior and API integration
• streaming rendering — Frontend and client engineering
• Streaming responses — LLM application UX
• Streaming transcription — Multimodal application integration
• streams — Distributed key-value stores and Redis
• stress testing — Performance and capacity
• Strong consistency — Distributed systems
• strongly connected components — Algorithms and data structures
• structural typing — Languages and runtimes
• structure-aware chunking — Knowledge-base ingestion
• Structured concurrency — Concurrency and parallelism
• structured errors — Tools, function calling, and MCP
• structured input — Prompt engineering
• Structured logs — Observability and debugging
• Structured outputs — Model behavior and API integration
• stubs — Testing and delivery
• stuck-loop detection — Agent loop engineering
• subnets — Infrastructure and cloud
• subqueries — Relational databases and SQL
• subscriptions — SaaS and business workflows
• subtyping — Languages and runtimes
• success criteria — Prompt engineering
• summaries — Observability and debugging
• Summaries — Memory engineering
• supervisor-worker — Agent harness and orchestration
• Supply-chain security — Testing and delivery
• swapping — Operating systems and hardware
• synchronization — Knowledge-base ingestion
• Synchronous replication — Distributed systems
• synchronous tools — Tools, function calling, and MCP
• System calls — Operating systems and hardware
• System instructions — Prompt engineering

T

• table bloat — Relational databases and SQL
• table locks — Transactions and concurrency control
• tables — Knowledge-base ingestion
• tail latency — Observability and debugging
• Tail latency — Performance and capacity
• tail sampling — Observability and debugging
• task completion rate — Evaluation engineering
• Task decomposition — Prompt engineering, Planning, reasoning, and verification
• Task framing — Prompt engineering
• task instructions — Context engineering
• task state — Context engineering
• task supervision — Concurrency and parallelism
• task-local instructions — Memory engineering
• tasks — Frontend and client engineering
• TCP — Networking and protocols
• TCP handshake — Networking and protocols
• team autonomy — Technical strategy and architecture judgment
• technical debt — Code design and maintainability
• technical debt prioritization — Technical strategy and architecture judgment
• Technical roadmaps — Technical strategy and architecture judgment
• technology adoption — Technical strategy and architecture judgment
• technology retirement — Technical strategy and architecture judgment
• temperature — Model behavior and API integration
• Temporal modeling — SaaS and business workflows
• Tenant configuration — SaaS and business workflows
• Tenant isolation — Security and privacy, Memory engineering
• tenant isolation — SaaS and business workflows, LLM performance and cost
• tenant provisioning — SaaS and business workflows
• tenant-aware keys — Caching
• tenant-aware retrieval — Retrieval and RAG
• terminal failure — Agent loop engineering
• test doubles — Testing and delivery
• test isolation — Testing and delivery
• Test pyramid — Testing and delivery
• Tests — Planning, reasoning, and verification
• text-to-speech — Multimodal application integration
• Thread dumps — Observability and debugging
• Thread pools — Concurrency and parallelism
• thread pools — Performance and capacity
• threads — Operating systems and hardware
• Threads — Concurrency and parallelism
• Threat modeling — Security and privacy
• throughput — Performance and capacity
• thundering herd — Reliability and resilience
• time budgets — Agent loop engineering
• Time to first token — LLM observability and debugging
• Time-series databases — Nonrelational databases and search
• timeout rates — LLM observability and debugging
• Timeouts — Reliability and resilience, Model behavior and API integration, Tools, function calling, and MCP
• timestamps — Memory engineering
• timezone boundaries — SaaS and business workflows
• timezones — Frontend and client engineering
• TLS — Networking and protocols, Security and privacy
• TOCTOU — Actions and side-effect safety
• toil — Reliability and resilience
• token allocation — Context engineering
• Token bucket — Rate limiting and admission control
• token budgets — Agent loop engineering
• Token usage — LLM observability and debugging
• tokenization — Nonrelational databases and search, Model behavior and API integration
• Tokens — Model behavior and API integration
• tombstones — Nonrelational databases and search
• tool calls — Model behavior and API integration
• tool contract testing — Tools, function calling, and MCP
• tool descriptions — Tools, function calling, and MCP
• Tool discovery — Tools, function calling, and MCP
• tool failure recovery — Agent loop engineering
• Tool failures — LLM observability and debugging
• tool granularity — Tools, function calling, and MCP
• tool latency — LLM observability and debugging, LLM performance and cost
• tool selection — Tools, function calling, and MCP
• tool spans — LLM observability and debugging
• tool supply chain — LLM application security
• tool-call budgets — Tools, function calling, and MCP
• tool-output injection — LLM application security
• Tool-result filtering — Context engineering
• Tool-result sanitization — Tools, function calling, and MCP
• Tool-selection accuracy — Evaluation engineering
• top-p — Model behavior and API integration
• topological sorting — Algorithms and data structures
• total cost of ownership — Technical strategy and architecture judgment
• trace context — Observability and debugging
• trace replay — LLM observability and debugging
• traces — Observability and debugging
• tradeoff analysis — Technical strategy and architecture judgment
• transaction boundaries — Transactions and concurrency control
• Transaction boundaries — Actions and side-effect safety
• transaction retries — Transactions and concurrency control
• Transactional outbox — Messaging and durable workflows
• transactions — Distributed key-value stores and Redis
• transcription latency — Multimodal application integration
• transport selection — Multimodal application integration
• tree shaking — Frontend and client engineering
• tries — Algorithms and data structures
• truncation — Model behavior and API integration
• Truncation — Context engineering
• Trunk-based development — Testing and delivery
• trust boundaries — LLM application security
• trust boundary — Security and privacy
• trust calibration — LLM application UX
• TTL — Networking and protocols, Rate limiting and admission control, Caching
• TTL jitter — Caching
• Tumbling windows — Data engineering
• turn detection — Multimodal application integration
• two pointers — Algorithms and data structures
• two-phase commit — Transactions and concurrency control
• two-phase locking — Transactions and concurrency control
• type inference — Languages and runtimes
• typed arguments — Tools, function calling, and MCP
• typed errors — Languages and runtimes
• Typed outputs — Tools, function calling, and MCP

U

• ubiquitous language — Architecture and domain modeling
• UDP — Networking and protocols
• unauthorized-action rate — Evaluation engineering
• uncertainty communication — LLM application UX
• undefined behavior — Languages and runtimes
• underspecification — Prompt engineering
• undo — LLM application UX
• union-find — Algorithms and data structures
• unit economics — Technical strategy and architecture judgment
• Unit tests — Testing and delivery
• unnecessary actions — Evaluation engineering
• unnecessary tool calls — LLM performance and cost
• untrusted documents — LLM application security
• untrusted tool outputs — Tools, function calling, and MCP
• URL state — Frontend and client engineering
• usage metering — SaaS and business workflows
• USE method — Observability and debugging
• user correction — Memory engineering
• User interruption — LLM application UX
• user isolation — Memory engineering
• User preferences — Context engineering
• user preferences — Memory engineering
• user requests — Prompt engineering
• user steering — Agent loop engineering, LLM application UX
• utilization — Performance and capacity

V

• Vacuum — Relational databases and SQL
• validators — Planning, reasoning, and verification
• Valkey — Distributed key-value stores and Redis
• value objects — Architecture and domain modeling
• Value semantics — Languages and runtimes
• variables — Prompt engineering
• variance — Languages and runtimes
• Vary — Caching
• vector clocks — Distributed systems
• Vector databases — Nonrelational databases and search
• vector distance — Retrieval and RAG
• vectorization — Operating systems and hardware
• Vendor dependency — Principal-level applied AI judgment
• verified completion — Agent loop engineering
• version columns — Transactions and concurrency control
• version pinning — Model behavior and API integration
• Versioned keys — Caching
• Versioning — APIs and integrations
• versions — Knowledge-base ingestion
• Vertical scaling — Performance and capacity
• video frames — Multimodal application integration
• Virtual machines — Infrastructure and cloud
• Virtual memory — Operating systems and hardware
• virtual nodes — Distributed systems
• Virtualization — Frontend and client engineering
• visibility — Concurrency and parallelism
• visibility timeouts — Messaging and durable workflows
• Voice activity detection — Multimodal application integration
• VPC — Infrastructure and cloud

W

• wait-free — Concurrency and parallelism
• WAL — Transactions and concurrency control
• Wall clocks — Operating systems and hardware
• Warmup — Performance and capacity
• WATCH — Distributed key-value stores and Redis
• watches — Distributed key-value stores and Redis
• watermarks — Data engineering
• Webhook signatures — APIs and integrations
• WebSockets — Networking and protocols
• Weighted requests — Rate limiting and admission control
• weighted-window approximation — Rate limiting and admission control
• wide-column stores — Nonrelational databases and search
• Word error rate — Multimodal application integration
• work stealing — Concurrency and parallelism
• workflow graph — Agent harness and orchestration
• Workflow-versus-agent choice — Principal-level applied AI judgment
• Working memory — Memory engineering
• workload identity — Security and privacy, Infrastructure and cloud
• Workspace management — Agent harness and orchestration
• write amplification — Nonrelational databases and search
• write policies — Memory engineering
• write skew — Transactions and concurrency control
• write tools — Tools, function calling, and MCP
• write-behind — Caching
• write-through — Caching

X

• XACK — Distributed key-value stores and Redis
• XAUTOCLAIM — Distributed key-value stores and Redis
• XSS — Security and privacy

Y

• YAGNI — Code design and maintainability

Z

• zero trust — Security and privacy
• Zero-shot prompting — Prompt engineering