track Redis-Like System Practice

Dispatch owns bytes to argv, parsing owns command selection, and the SET handler owns logging and reply transport directly.

Parsing owns bytes to argv, dispatch owns command selection, object storage owns typed state, AOF owns write logging, and output buffering owns reply bytes.

The SET handler owns parsing its own arguments and writing its reply to the socket; AOF and object storage only observe the result.

Object storage owns logging the write, since it knows the final state; the AOF layer only stores periodic snapshots of the keyspace, which the rewrite process then compacts in the background.

Only the expiration system needs to know; recovery loads everything and lookup will find the TTL eventually.

Only recovery and the AOF must agree, because once startup filtering runs, lookup needs no expiration logic at all, because offline deadlines were already handled before clients connected.

The reply layer decides on its own, checking the TTL just before serializing and substituting a null reply.

Recovery, expiration metadata, shared lookup, object storage, and reply serialization must agree that the expired key is logically gone.

Transaction state belongs on the client because it is per-connection command-building state; putting it in the global DB would leak across clients and keys.

Transaction state belongs in the global database so that EXEC from any connection can resume a transaction after a reconnect.

Transaction state belongs in the command table, since MULTI changes how subsequent commands are dispatched.

Transaction state belongs in a dedicated transactions database, so queued commands survive a crash and replay during recovery.

Full sync, because transferring a snapshot requires pausing the event loop for the entire duration of the transfer, since a forked child cannot share pages with a parent that keeps serving traffic.

Partial sync, because the backlog must record the slot of every key alongside its bytes.

Slot routing usually adds the broadest pressure because it changes key ownership, client routing, multi-key validity, and redirects across the architecture.

Failover, because promotion rewrites the entire keyspace into the new primary's storage format.

Server-owned keyspace mutation, complete command execution before reply, type checks before handlers, durable writes recorded in order, and clients owning connection-local state.

Replies flushed to the socket before the keyspace mutates, so clients never observe state that was not yet acknowledged.

Each handler validates its own bytes and manages its own socket, so no cross-layer rules are needed at all.

Single-threaded execution alone, since serialized commands make ordering, ownership, and type rules automatic — every other rule on the list simply restates what serial execution already guarantees.