Deep dives into tools,
techniques & the web.
Practical guides covering developer tools, health metrics, SEO, converters and more — written to be actually useful.
✦ AI-powered — understands natural language
Drag Rises With Speed Squared: The Real Cost of 130 km/h
Email List Deduplication and GDPR: Why "We Have This Person Eleven Times" Is a Compliance Question, Not Just a Mess
Three different "subscriber" CSV exports often contain the same person eleven times — with case variations, plus-addressing tags, and provider-specific formatting quirks. Under GDPR, duplicate contact records aren't just messy — they're a compliance question for "right to erasure" and access requests. Here's why email lists accumulate duplicates, the normalization steps before exact-match deduplication, and the consent-tracking implications of un-reconciled duplicates.
JWT vs Opaque Session Tokens: Why This Tool Can Decode Some Tokens and Not Others
Some APIs return a token that decodes into readable claims; others return an opaque string that reveals nothing. The difference isn't a quality signal — it's the fundamental architectural choice between stateless JWTs (the token contains the session data) and stateful opaque tokens (the token is a lookup key into a server-side session store). Here's why instant revocation pushes some systems toward the "extra database lookup" approach, and what it means when a token you paste into this tool decodes to nothing.
JSON Patch, Merge Patch, JSON Pointer, and JSON Path: The Standards Most Developers Don't Know
JSON Patch (RFC 6902) sends a list of operations (add, remove, replace, test) to modify a resource atomically. JSON Merge Patch (RFC 7396) uses a simpler merge rule. Here's both standards with examples, JSON Pointer path syntax, JSON Path for querying, and why the `test` operation enables optimistic concurrency.
Hreflang x-default: What Happens to Users Your Language Tags Don't Cover
"x-default" isn't a language code — it's a special hreflang value meaning "show this to anyone whose language/region didn't match any other entry." Omitting it doesn't make hreflang "invalid," but it delegates the "what do unmatched users see" decision to search engines' own logic. Here's the choice between a generic-international version and a language-selector page, why the selector page itself needs to participate in the reciprocal hreflang set, and why "x-default" never happens implicitly just because a URL "feels like" the main one.
Natural Sort vs Lexicographic: Why "file10 Before file2" Happens Differently in Every Language, Database, and File Manager
"file10" sorting before "file2" isn't a bug specific to one tool — it's the default lexicographic behavior across most programming languages, while file managers typically default to natural sort, creating a common mismatch. Here's how Python, JavaScript, SQL ORDER BY, and spreadsheets each handle this differently, and why version-number sorting (SemVer) is a related but distinct problem with its own rules.
"Ideal Weight" Gives You One Number — Health Guidance Gives You a Range, and the Difference Matters
"Ideal weight" formulas all output a single number — but health guidance (BMI ranges) is expressed as ranges, not single targets, and the gap between "a single target" and "a healthy range" matters for how people relate to these numbers. Here's why single-number framing can create "missed the target" feelings even within a healthy range, why it can encourage precision-seeking behaviors that body-fat-tracking articles already cautioned against, and why "healthy weight range" is generally the more useful framing.
Named Capture Groups, Lookahead, and Lookbehind: Modern Regex Features That Make Patterns Readable
Named capture groups turn regex matches from numbered tuples into readable dictionaries. Lookahead and lookbehind assertions match positions without consuming characters. Here's the modern regex feature set — named groups, non-capturing groups, all four assertion types — with practical patterns for log parsing and URL extraction.
alt="" vs No Alt Attribute: Why This Tiny Difference Means "Skip This" or "Announce the Filename"
alt="" and a missing alt attribute look nearly identical in your HTML editor — one extra empty-quotes substring — but to a screen reader, they mean opposite things: alt="" says "decorative, skip this," while missing alt often triggers an announcement of the filename itself. Here's the practical difference, why every img tag should have an alt attribute (even if empty), and the special case where alt="" on an image-as-link removes the link's accessible name entirely.
Why 9007199254740993 Becomes 9007199254740992: JSON Numbers and JavaScript's Precision Limit
A JSON number like 9007199254740993 can become 9007199254740992 just by being parsed in JavaScript — not a bug in the parser, but a mismatch between JSON's unlimited-precision number specification and JavaScript's double-precision floating point, which can't represent integers above 2^53 exactly. Here's why this specifically affects large database IDs, the common "represent as string" workaround, and why this creates cross-language inconsistencies when backends and JavaScript frontends disagree about what "the same number" means.
Unicode Fundamentals: ASCII History, UTF-8 Encoding, Byte Order Marks, and Why Mojibake Happens
ASCII was designed in 1963 for 7-bit telegraph machines. Every country's attempt to extend it to 8 bits was incompatible, producing mojibake when files crossed systems. Here's how Unicode solved the problem, why UTF-8 became dominant (backward compatibility with ASCII), what byte order marks are, and what character encoding corruption actually looks like.
Mbps vs MB/s: Why "100 Mbps" and "12 MB/s" Are the Same Number, Not a Problem
Your "100 Mbps" plan and your download manager's "12 MB/s" aren't a problem — they're almost exactly the same number, because internet speeds are measured in bits and file sizes in bytes, an 8x difference. Here's the Mbps-to-MB/s conversion, why "theoretical maximum" and "actual" speed differ for reasons unrelated to units (overhead, server limits, Wi-Fi, "up to" advertising), and why upload speeds are often a separate, much lower number worth checking.
Catastrophic Backtracking: Why a Regex That Works Instantly in Testing Can Hang Forever on Real Data
A find-and-replace that works instantly on a 100-character test string can take minutes (or never finish) on a 10,000-character real document — not because the engine is slow, but because certain regex patterns cause processing time to grow exponentially with input length. Here's how "catastrophic backtracking" works with patterns like (a+)+b, why it's invisible on short test inputs, why it's also a recognized security vulnerability (ReDoS), and how to recognize vulnerable pattern structures.
