Words, precision
and power.
The details behind text processing, encoding, and document formats.
✦ AI-powered — understands natural language
Why Your Reading Time Estimate Is Wrong — Reading Speed Research, Word Count Inconsistency, and Character Limits That Actually Matter
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.
Why Your Database Uses snake_case, Your JSON Uses camelCase, and Your .env Uses SCREAMING_SNAKE_CASE — and What Breaks When You Mix Them
Database column names, JSON fields, environment variables, and CSS classes each use different casing conventions — and each choice reflects a constraint from where that identifier is used. Here's why PostgreSQL lowercases your column names, the JSON snake_case vs camelCase cross-ecosystem problem, why environment variables are SCREAMING_SNAKE_CASE, and the file-name case-sensitivity bug that works on macOS and breaks on Linux production servers.
How Counting Characters Can Identify a Language — and Why It Gets More Reliable With Every Word
A character-counting algorithm can identify a language from a short text sample because every language has a dramatically different character frequency signature — English peaks at E (12.7%), German at E (17.4%) with distinct umlauts, Spanish with high A and the ñ character. Here's how n-gram comparison against language profiles works, why accuracy improves with text length, where language detection fails (code-switching, similar languages, proper nouns), and applications beyond language detection.
Why Copy-Paste From PDFs and Word Docs Silently Breaks Your Database: The Invisible Character Problem
A non-breaking space (U+00A0) looks identical to a regular space but doesn't trim with standard .trim(), doesn't match in string comparisons, and passes "not empty" validation on fields that look blank to users. Here's the taxonomy of invisible Unicode characters that cause real data quality bugs (not security exploits — the accidental kind from PDF and Word paste), where they come from, the specific bugs they cause, and how to reliably detect and clean them.
Where Lorem Ipsum Actually Comes From: Cicero, a Mid-Word Cut, and Centuries of Corruption
"Lorem ipsum" isn't a real Latin phrase — it's literally the tail end of "dolorem ipsum" ("pain itself"), cut off mid-word from a genuine passage of Cicero's philosophy, then scrambled and partially invented over centuries of typesetting. Here's the actual source text, how a coherent philosophical passage became nonsense, and why the "fakeness" arguably works in its favor as placeholder text.
Title Case Isn't One Rule: How AP, Chicago, and MLA Disagree on Prepositions and Hyphens
"The Art of War" or "The Art Of War"? AP style capitalizes 4+ letter prepositions; Chicago and MLA lowercase all prepositions regardless of length. Here's how major style guides disagree on prepositions, why hyphenated compounds are the hardest case for any automated title-case tool, and why "to" as an infinitive marker needs different treatment than "to" as a preposition.
Why Truncating Text at "Exactly 100 Characters" Is Harder Than It Looks: UTF-8, Word Boundaries, and HTML
Truncating at exactly 100 characters sounds simple — until you're splitting a multibyte UTF-8 sequence and producing invalid text, cutting mid-word and leaving "fo" dangling, or cutting HTML and leaving unclosed tags. Here's the byte vs code point vs grapheme cluster distinction, the word-boundary backtracking algorithm, why HTML truncation requires an actual parser (not string slicing), and why your ellipsis length has to come out of the character budget before you cut.
