Redis

Redis as an in-memory data-structure server: execution model, data types, memory management, persistence, replication, high availability, clustering, and common system-design uses.

A version-neutral guide to running Redis locally or in containers, with production security and persistence cautions.

Redis RDB snapshots and AOF persistence, fsync trade-offs, background rewrite/snapshot costs, recovery behavior, and what persistence does not guarantee.

MULTI/EXEC queuing, isolated execution, WATCH optimistic concurrency, error behavior, and why Redis transactions are not rollback-based ACID database transactions.

How Redis pipelining amortizes network round trips, how it differs from transactions and scripting, and why large pipelines must be bounded for memory/backpressure.

Redis fire-and-forget publish/subscribe semantics, pattern subscriptions, delivery limitations, and when Streams or a dedicated message broker are more appropriate.

Atomic server-side Redis scripting with EVAL/EVALSHA, KEYS/ARGV, script-cache behavior, cluster constraints, bounded execution, and when to prefer Redis Functions.

Using packet capture to inspect Redis TCP/RESP behavior in safe test environments, with TLS and credential/privacy cautions.

How Redis accepts and serves many TCP clients, connection limits, buffers, timeouts, backpressure, and why client-pool sizing matters.

Operational signal handling in Redis: graceful shutdown/reload-related behavior and why service managers and current Redis documentation should define production procedures.

How to benchmark Redis without confusing synthetic command throughput with application capacity, including concurrency, payloads, pipelines, latency percentiles, and hot-key effects.

How managed Redis changes responsibility for topology, failover, backups, networking, scaling, observability, and compatibility without changing Redis's core consistency limits.

Bloom-filter semantics, false positives, Redis bitmap implementations, scaling, and RedisBloom/module alternatives.

Rate limiting with Redis counters, fixed/sliding windows, token buckets, Lua atomicity, clock/expiry considerations, and production design trade-offs.

Stable Redis data-type semantics and use cases, with version-sensitive internal encodings separated from the public model.

Lists, blocking pops, Pub/Sub, sorted-set delayed queues, Redis Streams, and when a dedicated message broker is the better choice.

Lease-based locking with SET NX PX, ownership tokens, atomic release, renewal, failure windows, fencing tokens, and the limits of Redis replication/Redlock.

Practical Redis key naming, schema modeling, indexing, cardinality, hashes vs. strings, TTL boundaries, cluster hash tags, and why key scans should not become a query engine.

A compact guide to Redis command families and production-safe usage principles instead of a version-frozen command dump.

Redis event-driven command execution, I/O multiplexing, threaded network I/O, background work, and why the phrase 'Redis is single-threaded' needs qualification.

Why individually atomic Redis commands do not make multi-command application workflows atomic, and how INCR, WATCH, Lua/Functions, locks, and database constraints solve different races.

What Redis Slow Log measures, what it omits, how to configure and inspect it, and how to correlate slow commands with end-to-end latency.

A production-oriented guide to Redis stalls caused by slow commands, big keys, CPU saturation, persistence/fork, memory pressure, swap, networking, and client backpressure.

Why oversized Redis values or collections cause latency, bandwidth, memory, replication, deletion, and cluster-balance problems, plus safe detection and mitigation.

How one disproportionately popular key overloads a Redis shard, how to detect it, and strategies such as local caches, replica reads, key replication, request coalescing, and data-model changes.

Redis Cluster sharding with 16,384 hash slots, client redirection, hash tags, resharding, replica failover, and its consistency and multi-key constraints.

Redis Sentinel monitoring and failover for primary-replica deployments, including subjective/objective down states, quorum, failover authorization, promotion, and remaining consistency limits.

Redis primary-replica replication, full and partial synchronization, replication backlog, stale replica reads, and asynchronous failure semantics.

TTL semantics and Redis's combined passive and active expiration strategy, without depending on historical sampling constants.

How Redis memory is consumed, why RSS differs from logical dataset memory, fragmentation and allocator effects, maxmemory, expiry, eviction, and practical observability.

Redis maxmemory eviction policies including noeviction, LRU, LFU, random, TTL-focused policies, and how to choose among allkeys and volatile variants.

Modern Redis memory optimization through schema design, bounded cardinality, compact encodings, payload reduction, TTL/eviction, allocator observation, and instance sizing.