Words, precision
and power.
The details behind text processing, encoding, and document formats.
✦ AI-powered — understands natural language
Why `"abc" is "abc"` Is True But `"hello world" is "hello world"` Might Not Be — String Interning, Ropes, and Concatenation Complexity
Why sed's s/old/new/g Fails With File Paths — Delimiters, Capture Groups, and the GNU vs BSD sed Difference
sed's `s/old/new/g` fails when patterns contain forward slashes (like file paths) — but any character can be the delimiter: `s|/usr/local|/usr/share|g` works identically. Here's the complete sed substitution syntax including & for matched content and \1 capture groups, the -i in-place editing difference between GNU sed (Linux) and BSD sed (macOS), and why grep-first-then-sed is the workflow that prevents data loss.
Why Testing With Repeated Strings Reveals the Limits Your Code Doesn't Know It Has
String repetition in infrastructure contexts hits non-obvious limits: HTML maxlength vs database VARCHAR mismatches, DNS TXT records' 255-byte string limit requiring splits, HTTP header size limits enforced by the web server not the application, and template engine escaping that expands < to < — multiplying the size 4×. Here's the specific system limits worth testing at (255, 256, 4096, 65535 bytes) and the legitimate production uses for padding and progress bars.
Slug Design Beyond Single Pages — How Hierarchy, Tags, Authors, and Languages Shape Your URL Structure
Flat vs nested slug structures, author page cardinality problems, tag proliferation diluting content quality signals, and when CMS-generated slugs from titles produce wrong results for numbers and acronyms. Here's the slug architecture decisions that affect content series, taxonomies, and international content, plus why the language identifier belongs in the path prefix rather than embedded in the slug itself.
Why Stable Sorting Matters — Multi-Key Composition, Algorithm Stability, and the JavaScript Array.sort Change
A stable sort preserves the relative order of equal elements — which enables multi-key sorting by composing stable sorts. Sort by amount first, then by date (stable): the final result is ordered by date, with amount order preserved within each date. Here's which algorithms are stable (merge sort, Timsort, insertion sort) vs unstable (quicksort, heapsort), why JavaScript's Array.sort stability changed in 2018, and why numbers stored as text sort "10" before "2".
What Does "Duplicate" Actually Mean? The Normalization and Merge Decisions Behind Effective Deduplication
Deduplication is a business logic decision masquerading as a technical one — "duplicate" means different things for contact lists (same email, different fields) vs URL lists (case sensitivity, trailing slashes) vs product catalogs (same SKU, different descriptions). Here's the exact vs near-duplicate distinction, normalization as the preprocessing step that determines deduplication quality, CRM merge strategies, and URL-specific case sensitivity rules.
AR, SK, and 73: The Prosigns and Q Codes That Make Morse Code a Complete Communication Protocol
Morse code prosigns — like AR (end of message / "over"), SK (signing off / "out"), and KN (only the named station should reply) — are a complete communication protocol built into the code. Q codes like QTH (location), QSL (confirm receipt), and QRP (low power) provide internationally standardized shorthand that works across language barriers. Here's how a complete amateur radio Morse contact (QSO) is structured, and why 73 means "best regards."
Why Lorem Ipsum Is Statistically Biased for English Layouts — and When Content-First Design Is Better
Lorem Ipsum's Latin word-length distribution is statistically different from English, which is why layouts that look balanced with placeholder can break with real copy. Here's the average word length across languages, why button and navigation placeholder text is particularly misleading, how Cicero's long-sentence rhetorical style differs from web copy, and when content-first design eliminates the placeholder problem entirely.
Regex Works on Characters, Not Structure — Why It Fails on CSV, HTML, and JSON (and What to Use Instead)
Regex operates on characters, not structure — and applying it to CSV, JSON, or HTML routinely produces wrong results because the same pattern can appear in both structural positions (delimiters, field names) and content positions (inside field values). Here's why commas inside quoted CSV fields confuse naive regex, the HTML-parsing-with-regex problem, when regex on structured text is actually acceptable (log files, single-field formats), and the correct parsers for each format.
Word Count Isn't a Ranking Factor — Here's What Competitor Word Count Analysis Is Actually For
"Write 2,000+ words to rank" is confident, specific advice with weak evidence — longer pages rank well because comprehensive answers to complex questions require more words, not because length itself is a ranking signal. Here's how to actually use competitor word count data (look at the range, understand why longer pages are longer), why word count is a useful writing discipline tool in academic and professional contexts, and when character count matters more than word count.
When Changing a Slug Is Worth the SEO Cost — and the Exact Sequence to Follow When It Is
Changing a URL slug after publishing has permanent SEO consequences — but so does keeping a slug that contains a wrong date, a discontinued product name, or a keyword that's shifted. Here's when slug changes are genuinely warranted (vs when they're not worth the disruption), the correct 301-redirect-then-update-internal-links sequence, why CMS auto-slug-regeneration on title edit destroys rankings, and why year-in-slug is almost always a decision you'll regret.
Beyond ROT13: ROT47, ROT18, Atbash, and the Complete Family of Caesar-Style Rotation Ciphers
ROT47 extends ROT13 to all 94 printable ASCII characters — rotating digits and punctuation in addition to letters — but remains identically trivial to decode. Here's the full Caesar cipher family (ROT5 for digits, ROT13 for letters, ROT18 for both, ROT47 for all printable ASCII), Atbash's Hebrew origins (it appears in the Bible as the first known cipher in a religious text), and the modern use cases where ROT13 is deliberately not meant to be secure.
The Algorithm Behind "Remove Duplicates": Sort-Then-Scan vs Hash-Set, and When Each Is Right
"Remove duplicates" in a sorted list is a different operation than in an unsorted list — and which you need determines whether you must sort first, and whether you can process in a single pass. Here's the sort-then-scan vs hash-set trade-off (O(n log n) memory-efficient vs O(n) order-preserving), the "which occurrence to keep" question, and two edge cases most people don't think about until they hit them: blank lines and case sensitivity.
