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
Alphabetical Sort Order Isn't Universal: Locale Collation, Swedish Å, and Why Your Database Might Be Sorting Wrong
Alphabetical sort order isn't the same in every language — Swedish Å, Ä, Ö go at the end of the alphabet; German has two competing sort conventions for umlauts; Spanish ñ sits between n and o. Most sort tools and database defaults use Unicode code-point order, which is correct for English and wrong for nearly every other language. Here's what locale-sensitive collation actually is, how to configure it in SQL, JavaScript, and Python, and the case/accent-sensitivity dimensions on top of letter ordering.
Trailing Whitespace and Git Diff Noise: Why a One-Line Fix Can Show 200 Lines Changed
A one-line bug fix can show up as a 200-line diff if an editor's "trim trailing whitespace on save" setting touches every line in a file that previously had inconsistent trailing whitespace. Here's why this happens, git's whitespace-ignoring diff flags, dedicated "cleanup commit" practices for git blame hygiene, and the Markdown exception where trailing whitespace is actually meaningful.
How Plagiarism Detection Actually Works: From Exact-Match Shingling to Semantic Similarity, and Why Each Has Limits
Plagiarism-detection software doesn't search for "stolen sentences" — it converts text into mathematical representations (shingles, vectors, embeddings) and measures distance between them. Here's how exact-match shingling catches copy-paste-with-edits but misses paraphrasing, why semantic-embedding similarity catches paraphrasing but can't distinguish "copied" from "independently expressed similarly," and why similarity scores require human judgment to interpret.
What Actually Happens When You Repeat a String 1,000,000 Times — and Which Operations Become Catastrophically Slow
Repeating "abc" 1,000 times is a one-character operation in Python — but what you do with the result matters enormously. String concatenation in a loop with a large repeated string is O(n²); using join() is O(n); at scale, the difference is seconds vs hours. Here's what repetition actually creates in memory, which operations scale linearly vs quadratically on large strings, how JavaScript's "string ropes" differ from Python's contiguous buffers, and when virtual repetition (storing pattern + count) is better than materializing the full string.
Why "JohnSmith" and "johnsmith" Are the Same Account Here But Different Accounts There: Case Sensitivity in Login Systems
"JohnSmith" and "johnsmith" might be the same account on one platform and two different accounts on another — usernames, emails, and passwords each have different case-sensitivity conventions, and none of them are universal. Here's why email local-parts are technically case-sensitive but practically never are, why username case-sensitivity varies by platform and creates genuinely hard migration problems if changed later, why passwords must remain case-sensitive for security, and why mobile autocapitalize causes invisible login failures.
Why Layouts Approved with Lorem Ipsum Break When Real Content Goes In: The Length Mismatch Problem
A mockup gets filled with Lorem Ipsum, approved, and the real copy — 40% longer — breaks the layout in ways nobody saw during approval. The mismatch happens because placeholder text length is arbitrary (chosen to "look right") while real content length is determined by what needs to be said. Here's why headlines are the most commonly mismatched element, the "greek text vs realistic text" spectrum, and why testing multiple placeholder lengths (not just one) matters for layouts that are close to final.
Translation Text Expansion: Why German Runs Longer, Chinese Runs Shorter, and Your Layout Needs to Survive Both
A 1,000-word English document becomes roughly 1,300 words in German and roughly 700 words in Chinese — predictable averages that matter enormously for UI layout and print/subtitle budgeting, but can deviate wildly for short strings. Here's the commonly-cited expansion ratios by language, why pseudo-localization testing catches layout issues before translation even begins, and how expansion affects print page counts and video subtitling/dubbing differently than per-word translation costs.
Why "AMBULANCE" Is Written Backwards: Mirror Text, Ambigram Logos, and the Dyslexia Misconception
"AMBULANCE" written backwards on the front of an ambulance isn't a typo — it's designed to read correctly in a driver's rearview mirror. Here's how this functional mirror-text convention works, what ambigram logos actually require from letterform design, and why the popular "dyslexia means seeing letters backwards" characterization is a significant oversimplification of current research.
Morse Code Timing: Why "Faster" Means Rescaling Five Different Things at Once
A Morse code message can be sent anywhere from 5 to 40+ words per minute — but unlike typing speed, "faster" doesn't mean "the same dots and dashes, sooner." Every timing element (dot, dash, and three different gap types) is defined as a ratio relative to a single unit, and that unit scales together across all five elements at once. Here's how WPM is calibrated using the word "PARIS," why high-speed Morse becomes a perceptual rather than counted skill, and why Farnsworth timing deliberately breaks the proportional system for learners.
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.
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.
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.
