Resources
Blog
Deep-dives into text case formats, naming conventions, and formatting rules for developers, writers, and anyone who works with text.
Cleaning Messy Names and Company Data Before You Match or Merge Records
A repeatable pipeline for normalizing people and company names in a spreadsheet: whitespace, Unicode, accents, case rules that will not wreck McDonald or van der Berg, legal suffixes and safe duplicate detection.
Garbled Text Like é and ’: How to Diagnose and Fix Broken Encoding
Why café turns into café, how to tell whether the damage can be undone, and exact fixes for Excel, databases, web pages and code. Includes a symptom lookup table and a prevention checklist.
CSV Import Failing? Fix Delimiters, Quotes, Leading Zeros and Shifted Columns
A practical troubleshooting guide for CSV files that import with shifted columns, lost leading zeros, mangled dates or broken quotes, with checks you can run in two minutes.
camelCase API, snake_case Database: How to Convert Without Bugs
How to bridge a JavaScript front end and a SQL database that disagree on naming. Covers PostgreSQL case folding, where to convert, acronym traps and a safe migration plan.
Text Copied From a PDF Is a Mess: How to Fix Line Breaks, Hyphens and Odd Characters
Why PDF text pastes with chopped lines, split words and strange symbols, and a step by step cleanup that restores real paragraphs without retyping.
APA 7 Citations for Web Pages With No Author, No Date or No Title
How to cite web pages in APA 7th edition when information is missing, with clear decision rules for authors, dates, titles, retrieval dates and in-text citations.
Unexpected Token in JSON: The 10 Real Causes and How to Fix Each
A troubleshooting guide for JSON parse errors such as Unexpected token, Unexpected end of JSON input and Bad control character, with the exact cause behind each message.
Your Regex Works in the Tester but Fails in Your Code: The Differences That Matter
Why a regular expression behaves differently across JavaScript, Python, Java and PCRE, and how to avoid the global flag, escaping and Unicode traps that cause most surprises.
Debugging 401 Errors With JWTs: Reading Claims, Expiry and Signature Problems
How to decode a JSON Web Token, what each standard claim means, and the most common reasons a valid looking token is rejected, including seconds versus milliseconds and clock skew.
URL Encoding Bugs: Double Encoding, Plus Signs and Broken Query Strings
Why links break when special characters are encoded wrongly, how to spot double encoding such as %2520, and the correct way to build URLs in code with the right functions.
A UTM Naming Convention That Keeps Your Analytics Clean
How to design UTM source, medium and campaign rules that group correctly in GA4, avoid duplicate rows like Email and email, and survive a team of people tagging links.
A Sensible Password Policy for a Small Team: Length, Passphrases and Managers
Practical password rules based on current security guidance: why length beats complexity, how many bits a passphrase really has, and how to roll out a password manager.
How to Apply One Headline Capitalization Style Across a Whole Content Library
A workflow for auditing and fixing inconsistent headline capitalization on a site or in a document set, including the edge cases where AP, APA and Chicago disagree.
Why VLOOKUP Says Not Found When the Values Look Identical
How to find and remove the invisible characters that break lookups and joins, including non-breaking spaces, zero width characters and text numbers, with formulas for Excel and Google Sheets.
URL Slugs That Last: Transliteration, Length, Changes and Redirects
How to design clean URL slugs, handle accents and non-Latin titles, avoid collisions with reserved routes, and change a slug later without losing traffic.
YAML Indentation Errors and Silent Surprises in Kubernetes and CI Configs
How to fix YAML syntax errors, tabs, bad indentation and the quiet type problems like the Norway problem and version numbers that turn into decimals.
Timestamps and Time Zones: Fixing Off-by-Hours Bugs and Seconds vs Milliseconds
How to diagnose date bugs: Unix seconds versus milliseconds, UTC storage, daylight saving traps, JavaScript date parsing quirks and ISO 8601 offsets.
UUID v4 vs v7 for Database Primary Keys: Performance, Privacy and Practical Advice
When to use random UUID v4, when time ordered UUID v7 is better for indexes, how to store UUIDs efficiently and what they do and do not guarantee.
Base64 Pitfalls: btoa Errors, Missing Padding, URL-Safe Variants and Size Surprises
Solutions for the Base64 problems developers hit most: InvalidCharacterError with non-ASCII text, decoding failures, URL-safe alphabets, line breaks and the 33 percent size increase.
How to Clean and Deduplicate an Email List Without Losing Real Contacts
A careful workflow for extracting, normalizing and deduplicating email addresses, including case, whitespace, plus addressing and what you must never merge.
Fancy Unicode Text Looks Great but Breaks Things: Accessibility, Search and Safe Alternatives
What really happens to bold, script and bubble Unicode text in screen readers, search, usernames and filters, and how to get emphasis without those problems.
Fixing Low-Contrast Text: WCAG Ratios, Brand Colors and Practical Adjustments
How to measure color contrast, what ratios WCAG requires for text and interface elements, and how to adjust a brand color so it passes without losing its character.
Capitalization in Academic Writing: APA, MLA, and Chicago Rules
APA capitalizes titles differently in the text versus the reference list. MLA has its own headline-style rule. Chicago offers two systems. Here's how capitalization works across the three major academic style guides.
Comparing Two Versions of a Document, Config or Contract: A Practical Diff Workflow
How to compare text versions reliably: pick the right granularity, remove noise before comparing, normalize JSON and spot moved paragraphs, with the limits of simple diffs.
How to Fix Long, Hard-to-Read Sentences: A Measured Rewrite Method
A practical method for finding and fixing overlong sentences, with measurable targets, before and after examples and the rewriting moves that work.
Using a Word Frequency Audit to Improve SEO Writing Without Keyword Stuffing
How to analyze a draft with word frequency counts, spot accidental overuse and missing topics, and place keywords naturally where they matter.
Why OCR Gets Text Wrong and How to Improve Accuracy on Screenshots, Scans and Photos
Practical steps that raise optical character recognition accuracy: capture settings, image cleanup, language choice, common character confusions and a proofreading routine.
Migrating Documents to Markdown: A Workflow for Word, PDF and HTML Sources
How to convert existing Word files, PDFs and web pages to clean Markdown for a docs site or repository, including what each source loses and how to check the result.
Building a SQL IN Clause From a Spreadsheet Column: Quoting, Limits and Safer Alternatives
How to turn a list of values into a correct IN clause, with the pitfalls that cause wrong results: quotes, NULL in NOT IN, type mismatches, list size limits and injection risk.
QR Codes That Actually Scan: Size, Contrast, Error Correction and Content Choices
Why QR codes fail to scan on print and screens, and how to fix it: minimum size, quiet zone, contrast, error correction levels, data length and testing before you print.
MD5, SHA-256 or bcrypt? Choosing the Right Hash for Checksums, Integrity and Passwords
A clear guide to which hash function fits which job, why MD5 and SHA-1 are broken for security, why SHA-256 is wrong for passwords and what to use instead.
Writing Amounts in Words on Cheques, Invoices and Contracts Without Errors
How to write money and numbers in words correctly: hyphens, the word and, decimals, currency units, which version prevails when words and figures disagree and how to prevent tampering.
Text Case in CSS: text-transform and When to Use It
The CSS text-transform property lets you render text as uppercase, lowercase, or title case without changing the underlying content. Here's how it works, where it's useful, and the critical difference between visual case and real case.
How to Standardize Codebase Naming Conventions Across Teams
Inconsistent naming conventions slow down code reviews, confuse developers, and lead to bugs. Here is a practical guide to establishing, documenting, and automatically enforcing text case rules across team projects.
REST API Naming Conventions: Case Rules for URLs, JSON, and Headers
Which case format should your API use for URL paths, query parameters, JSON keys, and HTTP headers? Here's what the major APIs do, what the specs say, and how to stay consistent.
Case Sensitivity Explained: Why Computers Treat A and a Differently
Why does your password fail when Caps Lock is on? Why do some file systems treat README.md and readme.md as different files? Case sensitivity is one of computing's most misunderstood concepts — here's how it actually works.
A Beginner's Guide to Text Case Conversion: When and Why It Matters
Not sure when to use uppercase, title case, or camelCase? This plain-language guide walks through every common text case format, explains the rules behind each one, and shows you exactly when to use them.
When to Capitalize Seasons, Directions, and Time Periods
Do you capitalize spring, summer, fall, and winter? What about north, south, east, and west? The rules are more specific than most writers realize — here's a complete guide.
Capitalization After a Colon: The Complete Rule
Should you capitalize the first word after a colon? The answer depends on what follows. Here's the full rule — what AP Style, Chicago, and MLA say, and how to apply it in practice.
Capitalization Rules in Other Languages: How the World Capitalizes Differently
German capitalizes every noun. French doesn't capitalize months, days, or nationalities. Japanese has no concept of uppercase at all. Here's how capitalization works across major world languages — and what English speakers get wrong.
Capitalization in Email Writing: Subject Lines, Greetings, and Sign-offs
Should email subject lines use title case or sentence case? How do you capitalize a greeting? What about sign-offs? Here are the rules — and why most people get at least one of them wrong.
Text Case in Brand Names: Why Brands Capitalize Differently
adidas is all lowercase. IKEA is all caps. iPhone breaks a sentence mid-word. Brand capitalization is deliberate — here's the logic behind how major companies use case as part of their identity.
How to Capitalize Job Titles: A Complete Style Guide
Should it be 'Director of Marketing' or 'director of marketing'? The answer depends on context. Here's the full rule set for capitalizing job titles in formal writing, email, and web copy.
What Is PascalCase? A Complete Developer's Guide
PascalCase is the universal convention for class names, TypeScript types, and React components. This guide explains what it is, where every major language requires it, and how it differs from camelCase.
What Is camelCase? A Complete Developer's Guide
camelCase is the dominant naming convention in JavaScript, Java, and JSON. This guide explains what it is, where it's required, how it got its name, and how it compares to PascalCase, snake_case, and kebab-case.
Text Case for SEO: URL Slugs, Title Tags, and Headings
How you capitalize URLs, title tags, and headings has a measurable impact on SEO and click-through rates. Here's what Google's guidance says about case in URLs, and best practices for title case in meta titles and headings.
Naming Conventions in 6 Major Programming Languages
Every programming language has its own rules for naming variables, functions, classes, and constants. Here's a complete reference for JavaScript, Python, Java, C#, Go, and Rust — and why the conventions differ.
Alternating Case and Inverse Case: What They Are and Where They Show Up
Two less conventional case formats — alternating case and inverse case — have specific uses in internet culture, creative contexts, and practical text editing. Here's what they are, how they work, and when you'd actually use them.
CONSTANT_CASE: How to Name Constants Across Every Language
CONSTANT_CASE (also called SCREAMING_SNAKE_CASE or UPPER_SNAKE_CASE) is the universal convention for naming constants in code. Here's where it's used, why it exists, and how it differs from regular snake_case.
kebab-case: The Web Developer's Complete Guide
kebab-case is the standard for URLs, CSS properties, HTML attributes, and npm package names. This guide explains where it's required, why hyphens are used instead of underscores, and how it compares to other case formats.
What Is snake_case? A Complete Developer's Guide
snake_case is the dominant naming convention in Python, databases, and environment variables. Here's a full breakdown: what it is, where it's required, and how it compares to camelCase and kebab-case.
UPPERCASE Text: When All Caps Works (and When It Doesn't)
ALL CAPS is powerful when used correctly and exhausting when overused. Here's a complete guide to when uppercase text improves communication — and when it undermines it.
What Is Sentence Case and When Should You Use It?
Sentence case is the most natural capitalization style in English — but it's often confused with title case. Here's what it is, where it works best, and common mistakes to avoid.
snake_case vs kebab-case: A Developer's Guide
Both use lowercase letters and delimiters to separate words — but one uses underscores and the other hyphens. Here's exactly where each belongs and why you can't swap them.
Title Case Rules Explained: Which Words Get Capitalized?
Title case sounds simple until you hit prepositions, articles, and conjunctions. Here's a full breakdown of the rules — and why different style guides disagree.
camelCase vs PascalCase: Which Should You Use?
camelCase and PascalCase look almost identical — one letter of difference. But that difference determines whether your code is correct or broken. Here's a full language-by-language guide.