iOS System Design

GCD schedules work on dispatch queues. A serial queue runs tasks one at a time and can guard shared state without locks; a concurrent queue runs many at once. All UI updates must run on the main (serial) queue.

Layer a fast in-memory cache over a disk cache that survives relaunch, checking memory, then disk, then network. Decode and downsample on a background queue so the main thread only draws. Coalesce requests keyed by URL so the network is hit once, and return a cancellable token so cell reuse cancels the stale load. Keep the public surface tiny — one load-into-target call and one cancel.

URLSession runs HTTP requests via data tasks, returning data, response, and error. For offline support you persist successful responses locally (URLCache, a disk store, or a database) and serve the cached copy when a request fails, showing last-known data offline.

Back it with a persistent, reorderable download queue that supports pause and resume. Track total saved bytes against the user's budget and evict before exceeding it, by a least-useful rule — the oldest already-played episodes first. On a real disk-full or a budget hit, tell the user exactly what will be removed or that they must free space, instead of failing silently.

Page with an opaque server cursor rather than page numbers, so inserts never shift or repeat rows. Prefetch the next page when the user nears the end, driven by the list's prefetch hook, so scrolling never stalls. On refresh, merge new items and dedupe by stable id against what is already shown. Persist the last page so a cold offline start renders cached content with an offline indicator, not a blank screen.

Keep a local message store ordered by a server sequence or timestamp, not arrival order, so out-of-order socket frames still render correctly. Persist unsent messages in an offline queue and flush them in order on reconnect, keyed so retries never duplicate. Track delivery and read state per message. Reconnect the socket with backoff and replay any gap. Page older history from REST on demand.

Run downloads on a background URLSession so they survive an app kill and resume from partial data via resume data or an HTTP range request, not from zero. A bounded queue caps concurrency and orders tasks by caller priority so a visible download preempts a background one. Report progress from the session's byte-level callbacks, and check free disk space before enqueuing so a low-space start fails cleanly.

Use CoreLocation with an accuracy and distance filter tuned to the use case, and adapt the sample rate to movement — frequent while moving, sparse while still — so the battery is not drained. Buffer fixes locally and upload them in batches instead of one call per fix. Keep sharing alive in the background with the location capability, and when offline, persist fixes and flush them when the connection returns.

Build an inverted index — tokens mapped to record ids — and persist it on disk (SQLite FTS or a file store), not in RAM, so it survives launches without rebuilding. Query it directly for prefix and fuzzy matches, ranking by term frequency. Keep it fresh incrementally: on a catalog delta, update only the changed records' postings instead of rebuilding the whole index. Load it lazily so launch stays fast.

Treat a push as a hint, not the truth — dedupe its payload against the server fetch by a stable message id so a message never appears twice. Derive the badge count from the reconciled unread set rather than by counting pushes, and clear it as items are read. On reopening after many dropped or coalesced pushes, fetch authoritative server state instead of trusting that every push was delivered.

Split into a container that owns the tabs plus a per-tab collection module driven by a cell factory keyed on the backend-described data type, so new tab/cell kinds need no UI changes. Model the selected month as shared state (a coordinator or shared store) so changing it on one tab propagates to all; pull-to-refresh reloads every tab. Cache responses per month/tab to cut traffic, and show placeholder-plus-reload with no cache or an error over cached data when present.

Buffer events through a thread-safe serial queue, persist them to a disk-backed queue immediately so a crash loses nothing, and flush in batches triggered by time or count. Define a transport protocol so multiple pluggable backends can be added/removed at runtime, and route by priority — high flushes now, normal batches, low waits for WiFi + charging. Keep one small public log API stable while internals evolve.

Cache the flag set on disk and evaluate synchronously from that snapshot, so a screen never waits on the network. Refresh in the background and swap the snapshot atomically, never blocking launch — first run falls back to compiled-in safe defaults. Assign each user a variant from a stable hash of user id and experiment key so it survives refreshes. Log an exposure event when a flag is read.

Each device appends edits to a local change log and syncs the log, not the whole note, so edits merge instead of overwriting. Track a version per note — per-device counters — to detect concurrency. Merge non-overlapping changes automatically; when edits truly collide, keep both via a conflict copy rather than dropping one. The user sees a non-destructive outcome and never loses text.

Play an HLS stream through AVPlayer and let its adaptive-bitrate logic pick a variant from measured bandwidth, prebuffering a few seconds ahead so playback starts fast. Cache recent segments so short seeks and replays skip the network. On a mid-play drop, keep playing to the buffered edge, show a buffering state, and resume from the same position when connectivity returns rather than restarting the video.

For marker visibility, sort destinations by popularity descending and greedily place markers within the current viewport — skip any whose footprint overlaps an already-placed (more popular) marker. Recompute on every pan/zoom and on price updates. Debounce autocomplete and cache city lists; prefill From via CoreLocation. Persist the last destination/price set so the map and markers still render offline, refreshing prices when the connection returns.