Name: System Design Masterclass
Availability: InStock

The previous lesson measured what cache-aside costs: the key computed at every call site, the value shape assumed at every call site, and a failure path that only exists where somebody wrote it. Read-through moves the fetch inside the cache. The application asks for a key, and the cache loads it if it is not there.

Two panels. Cache-aside owns the key and the fetch at every call site, so each one can differ, with keys reading where the logic is your call sites and failure decision visible. Read-through owns the key and the loader in one place, so they cannot differ, with keys reading where the logic is one loader and failure decision hidden. — ComparisonFigure 1. Read-through fixes the duplication the previous lesson measured, and hides one decision
The key, the time to live, the single flight and the fetch all move into one loader. So does what happens when that fetch fails, and that is the one this lesson is about.

Five rows. Key drift is impossible, since one loader builds every key. Shape drift is impossible, since one loader decides the value. Missing single flight is built in, so concurrent misses collapse. A forgotten TTL is set once, in a place somebody reviews. And the failure path is still a decision, and now a hidden one. — FigureFigure 2. Four of the five problems stop being possible rather than being solved
That is a much stronger property than being fixed. A bug that cannot be expressed does not come back when somebody adds a sixth call site next quarter.

A sequence diagram between fifty callers, the cache and the source. All fifty ask for the same missing key. One load is started. The other forty-nine wait. And all fifty get the same result, noted as being code you write in cache-aside. — SequenceFigure 3. The cache knows two callers want the same missing key. Your call sites do not
This is the stampede from the lazy loading lesson, removed by construction. It is worth more than it looks, because the stampede is worst on your most popular key immediately after a restart.

Centralising the fetch is a genuine improvement and it is also why the failure behaviour stops being obvious. In cache-aside somebody had to write a try block. In read-through somebody has to know what the library already does.

Four rows. Propagate, meaning let the exception reach the caller and cache nothing. Cache a fallback, meaning return a safe default and store it with the normal TTL. Short negative, meaning store the default with a much shorter TTL. And serve stale, meaning keep the previous value past its expiry and use that. — FigureFigure 4. Four defensible behaviours, all in production somewhere, all different
Nothing about read-through picks one for you. The library has a default and most teams inherit it without ever choosing, which is fine until the day the source is unavailable for three seconds.

Where this shows up in interviews

Where this shows up in interviews

Read-Through Cache

The rest of this lesson

Continue this lesson

One Loader Instead Of Many Call Sites

The Decision That Moved Out Of Sight