Sensei on the Road

Sensei episode: Blurring What Is Behind an Element Instead of the Element Itself. Written for the ear.

Sensei episode: Web02 Cutting A Shape Out Of A Rectangle The Browser I. Written for the ear.

Sensei episode: The Collapsible Panel That Needs No JavaScript at All. Written for the ear.

Sensei episode: Inodes and Why Deleting a File Does Not Free the Space. Written for the ear.

Sensei episode: In03 Memory Management. Written for the ear.

Sensei episode: In02 Cpu Scheduling. Written for the ear.

Sensei episode: System Calls: The Only Door Between Your Code and the Kernel. Written for the ear.

Sensei episode: Exactly Once Delivery: Why It Does Not Exist and What You Get Instead. Written for the ear.

Sensei episode: Backpressure: Why an Unbounded Queue Is a Hidden Outage. Written for the ear.

Sensei episode: Exponential Backoff and Jitter: Why Polite Retries Still Cause Outages. Written for the ear.

Sensei episode: Circuit Breaker. Written for the ear.

Sensei episode: LSM Trees and B-Trees: Why the Write Path Decides the Read Path. Written for the ear.

Sensei episode: Bloom Filters. Written for the ear.

Sensei episode: Write Ahead Logging: Why Databases Write Everything Twice. Written for the ear.

Sensei episode: Erasure Coding Vs Replication. Written for the ear.

Sensei episode: What Is A Tombstone In Databases. Written for the ear.

Sensei episode: Multi Version Concurrency Control: Why Readers Never Block Writers. Written for the ear.

Sensei episode: Password Hashing: Why Encryption Is the Wrong Tool for Passwords. Written for the ear.

Sensei episode: Mutual TLS. Written for the ear.

Sensei episode: JWT Security: What a Signed Token Cannot Tell You. Written for the ear.

Sensei episode: OAuth 2.0 vs OIDC. Written for the ear.

Sensei episode: Lb Vs Api Gateway. Written for the ear.

Sensei episode: Voiced. Written for the ear.

Sensei episode: Sharding and Partitioning — System Design on the Road, Ep. 09. Written for the ear.

Sensei episode: Idempotency — System Design on the Road, Ep. 08. Written for the ear.

Pacelc V2

A successful write in Virginia and a successful read in Frankfurt one second later disagreed — with no partition, no packet loss, and every dashboard green. That is the gap CAP cannot explain and PACELC fills. CAP only describes the choice you make during a network fault, which is rare. PACELC adds the clause that governs the other 99.9% of your system's life: if there is a Partition, choose Availability or Consistency; ELSE, choose Latency or Consistency. Because consistency is not a property you have — it is coordination you pay for, and coordination costs a round trip you cannot argue with. Covered: • Why a healthy network still forces a trade-off (2 ms local ack vs ~90 ms cross-ocean) • The two-letter classification: Dynamo-style PA/EL, synchronous Postgres PC/EC, Spanner PC/EC — and the hardware invoice behind TrueTime that people skip when they claim consistency is free • Why the choice is per operation, not per database • The consistency stack: eventual, the session guarantees (read-your-writes and monotonic reads, which sit side by side rather than in a queue), causal, and strong • The quorum inequality R + W > N as the dial you actually turn — and why that is read-write overlap, not linearizability • Why choosing strong consistency everywhere out of caution can produce something less reliable than the eventually-consistent design you were afraid of Sequel to Ep. 02 (The CAP Theorem). Written for the ear. Hafs Ibrahim · Deep Systems · 𝕏 @hafs_darwish · github.com/hdarwish · herald.hafs.dev

A 3 a.m. autopsy of a checkout latency cliff: why an unindexed query that was fast for two years fell off a wall overnight. B-trees vs binary trees and why disk pages shape the tree, selectivity and why the optimizer overrules your index, the write penalty every index charges forever, partial indexes, leftmost-prefix rules for composite indexes, covering indexes and index-only scans, and reading EXPLAIN ANALYZE.

Your payment service charged the card twice and nothing failed. This episode takes apart asynchronous messaging: why a queue is a mailbox not a phone call, the three delivery guarantees (at-most-once, at-least-once, exactly-once), why exactly-once delivery across a network is provably impossible, and how idempotent consumers with a stable dedupe key solve it for real. Written for the commute — no diagrams, just intuition. Sensei — System Design on the Road, Ep. 05.

Sensei breaks down caching for the commute: why the fastest request is the one you never make, the cache-aside pattern, and the truly hard part — cache invalidation and staleness. TTL, write-through, and delete-on-change as freshness-vs-speed trade-offs, anchored in feeds, CDNs, and real systems. System Design on the Road, Ep. 04.

How systems protect themselves when one caller floods them. The token bucket and leaky bucket algorithms explained for the ear, plus the hard part nobody mentions: keeping the counter honest across many servers. System Design on the Road, Ep. 3, narrated by Sensei.

A commute-learning episode on the CAP theorem: consistency, availability, and partition tolerance — why you can only hold two during a failure, and how real engineers decide which to sacrifice. Written for the ear. Sensei — System Design on the Road, Ep. 2.

Why plain modulo hashing wrecks your cache when servers change, how the hash ring fixes it, and why virtual nodes matter. Written for the ear.

Sensei episode: Q Learning And Exploration. Written for the ear.

Sensei episode: Mdp And Bellman. Written for the ear.

Sensei episode: t-SNE and How to Misread a Cluster Plot. Written for the ear.

Sensei episode: PCA and What Eigenvectors Actually Mean. Written for the ear.

Sensei episode: DBSCAN: Clustering Without Choosing k. Written for the ear.

Sensei episode: Kmeans And Initialization. Written for the ear.

Sensei episode: XGBoost: Why Making Every Step Weaker Wins. Written for the ear.

Sensei episode: Boosting vs Bagging: Why the Method That Studies Its Mistakes Sometimes Loses. Written for the ear.

Sensei episode: Naive Bayes: Why an Assumption That Is Wrong Still Classifies Correctly. Written for the ear.

Sensei episode: k-NN and the Curse of Dimensionality. Written for the ear.

Sensei episode: SVMs and the Kernel Trick — AI Concepts Decoded, Ep. 05. Written for the ear.

Sensei episode: Bias, Variance, and Random Forests. Written for the ear.

Sensei — AI Concepts Decoded

Why squashing a linear model is the easy half of the fix, and squared error is the real bug. Log-odds, cross-entropy as negative log-likelihood, the gradient that collapses to prediction minus label, perfect separation, and why the threshold is never the model's job.

Why data never picks your model, how least squares turned an infinite search into one number, and why the exact solution to linear regression is useless at scale. From Gauss recovering a lost asteroid to gradient descent in a ravine.