Complete Guide to Text Case Conventions: camelCase, snake_case, kebab-case & More

Python (PEP 8)

# Variables and functions: snake_case
user_name = "alice"
max_retry_count = 3

def calculate_total(item_list):
    return sum(item.price for item in item_list)

# Classes: PascalCase
class UserProfile:
    def __init__(self, name):
        self.name = name

# Constants: SCREAMING_SNAKE_CASE
MAX_CONNECTIONS = 100
DEFAULT_TIMEOUT = 30

JavaScript / TypeScript

// Variables and functions: camelCase
const userName = "alice";
let retryCount = 0;

function calculateTotal(itemList) {
  return itemList.reduce((sum, item) => sum + item.price, 0);
}

// Classes and React components: PascalCase
class UserAccount {
  constructor(name) { this.name = name; }
}

// React component (must be PascalCase)
function UserProfilePage({ userId }) { ... }

// Constants: SCREAMING_SNAKE_CASE
const API_BASE_URL = "https://api.example.com";
const MAX_RETRIES = 5;

Java

// Variables and methods: camelCase
String userName = "alice";
int maxRetryCount = 3;

// Classes and interfaces: PascalCase
public class UserProfile { ... }
public interface Callable { ... }

// Packages: dot.case (all lowercase)
package com.example.userprofile;

// Constants: SCREAMING_SNAKE_CASE
public static final int MAX_CONNECTIONS = 100;

C#

// Local variables and parameters: camelCase
string userName = "alice";
int retryCount = 0;

// Public members, methods, classes: PascalCase
public class UserProfile
{
    public string UserName { get; set; }
    public int CalculateScore(int baseScore) { ... }
}

// Private fields: _camelCase (underscore prefix)
private string _internalCache;

Rust

// Functions and variables: snake_case
fn calculate_total(items: &[Item]) -> u64 { ... }
let user_name = "alice";

// Types (structs, enums, traits): PascalCase
struct UserProfile { name: String }
enum StatusCode { Ok, NotFound }
trait Serializable { ... }

// Constants and statics: SCREAMING_SNAKE_CASE
const MAX_BUFFER_SIZE: usize = 4096;

// Crate names: kebab-case (in Cargo.toml)
// crate-name = "0.1.0"

Go

// Unexported (private): camelCase
func calculateTotal(items []Item) int { ... }
var internalCache map[string]string

// Exported (public): PascalCase — this IS the access modifier
func NewUserProfile(name string) *UserProfile { ... }
type UserProfile struct { Name string }

// Interfaces: PascalCase, often -er suffix
type Reader interface { Read(p []byte) (n int, err error) }

Ruby

# Variables, methods, symbols: snake_case
user_name = "alice"
def calculate_total(items) ... end
:some_symbol

# Classes and modules: PascalCase
class UserProfile; end
module Authentication; end

# Constants: SCREAMING_SNAKE_CASE (or PascalCase)
MAX_RETRIES = 5
DEFAULT_HOST = "localhost"

# Gems: kebab-case
# gem 'my-awesome-gem'

PHP (PSR standards)

// Variables: camelCase or $snake_case (style-dependent)
$userName = "alice";

// Class methods: camelCase (PSR-1)
class UserProfile {
    public function getFullName(): string { ... }
    public function calculateAge(): int { ... }
}

// Classes: PascalCase (PSR-1)
class UserService { ... }

// Global functions: snake_case (common convention)
function validate_email($email) { ... }

// Constants: SCREAMING_SNAKE_CASE
const MAX_UPLOAD_SIZE = 10485760;

SQL

-- Keywords: UPPERCASE (widely preferred)
SELECT user_name, email_address
FROM user_profiles
WHERE created_at >= '2026-01-01'
ORDER BY user_name ASC;

-- Table and column names: snake_case
CREATE TABLE blog_posts (
    id SERIAL PRIMARY KEY,
    post_title VARCHAR(255),
    created_at TIMESTAMP
);

CSS / HTML

/* CSS properties: kebab-case */
.hero-section {
  background-color: #070712;
  border-radius: 1.5rem;
  font-size: 1rem;
}

/* HTML attributes: kebab-case */
<div data-user-id="123" aria-label="Navigation">

/* BEM methodology: kebab-case with __ and -- */
.nav-bar { }
.nav-bar__item { }
.nav-bar__item--active { }

URLs: Always kebab-case

Search engines treat hyphens as word separators but underscores as connectors. Google explicitly recommends hyphens. URLs in kebab-case are also easier to read when shared on social media or in emails.

✓ /blog/complete-guide-to-text-case-conventions
✗ /blog/completeGuideToTextCaseConventions
✗ /blog/Complete_Guide_To_Text_Case_Conventions

File Names: kebab-case preferred

File names with kebab-case work consistently across Windows, macOS, and Linux. Spaces cause issues in terminal commands, camelCase creates confusion about casing on case-insensitive file systems (macOS default), and underscores are harder to read in URLs when files get linked.

✓ case-conversion-guide.md
✓ api-reference-v2.json
✗ Case Conversion Guide.md
✗ apiReferenceV2.json

Blog Title & Heading Styles

Blog post titles typically use Title Case, following either AP Style or Chicago Manual of Style rules. The difference: AP lowercases words with fewer than four letters; Chicago lowercases all articles, prepositions, and coordinating conjunctions regardless of length.

# Title Case (AP style)
"A Complete Guide to Text Case Conventions"

# Title Case (Chicago style)
"A Complete Guide to Text Case Conventions"

# Sentence case (modern blogs, Medium, Substack)
"A complete guide to text case conventions"

UI Labels: Sentence vs. Title Case

Modern design systems (Material Design, Apple HIG, Shopify Polaris) favor sentence case for UI labels, buttons, and form fields. It's faster to scan and feels more conversational. Title Case is reserved for proper nouns within labels.

✓ "Create new account" (sentence — modern)
~ "Create New Account" (title — traditional)
✓ "Upload to Google Drive" (sentence + proper noun)

Email Subject Lines

Email marketing data shows sentence case subject lines get slightly higher open rates (they feel less "salesy"). Title Case is still common in transactional emails and formal communications. The key rule: be consistent within your brand voice.

Social Media & Hashtags

Hashtags use PascalCase for accessibility (screen readers parse #TextCaseConverter far better than #textcaseconverter). Twitter/X handles are case-insensitive but conventionally lowercase. Campaign URLs should always be kebab-case for tracking UTM parameters.

Using camelCase or PascalCase in URLs

Search engines don't parse camelCase word boundaries. /myBlogPost is treated as one word, not three. Always use kebab-case (/my-blog-post) for SEO, readability, and consistency with web standards.

Inconsistent casing within the same project

Mixing getUserData and get_user_info in the same codebase creates confusion. Pick one convention per language/context and enforce it with linters (ESLint, pylint, rubocop) and formatters (black, prettier, ruff).

Mixing snake_case and kebab-case in file names

A project with both user_profile.py and user-settings.json introduces inconsistency. Choose one file naming convention per project and document it. Python projects typically use snake_case files; web projects typically use kebab-case.

Forgetting locale-specific capitalization rules

The Turkish "I problem" is notorious: in Turkish, the lowercase of "I" is "ı" (dotless i), not "i" — and the uppercase of "i" is "İ" (dotted I). Naive .toUpperCase() calls break Turkish text. Always specify locale when case-converting user content. Similarly, German "ß" uppercases to "SS" (or "ẞ" in newer standards).

Using PascalCase for variables in Python

Writing UserProfile = fetch_user() in Python makes it look like a class, not a variable. Python developers reading your code will be confused. PEP 8 mandates snake_case (user_profile = fetch_user()) for everything that isn't a class or constant.

Title Case overuse in modern UI

Using Title Case for every UI element ("Edit Your Profile Settings", "Save Changes Now") feels heavy and dated. Modern interfaces use sentence case for most labels, reserving Title Case for product names, proper nouns, and primary navigation headers.

1. Word Boundary Detection

The first step is splitting input into individual words. The converter looks for several boundary signals:

// Spaces: "hello world" → ["hello", "world"]
// Underscores: "hello_world" → ["hello", "world"]
// Hyphens: "hello-world" → ["hello", "world"]
// camelCase transitions: "helloWorld" → ["hello", "world"]
// Acronym boundaries: "getHTTPResponse" → ["get", "HTTP", "response"]

The tricky case is acronyms in camelCase. "getHTTPResponse" should split as three words, not "get H T T P Response." Smart converters detect sequences of uppercase letters followed by a lowercase transition.

2. Numbers and Special Characters

Numbers create implicit word boundaries. "my2ndVariable" splits into ["my", "2nd", "variable"]. The converter must decide whether digits attach to the preceding or following word — most implementations treat digit-to-letter transitions as boundaries:

"file2name" → snake_case → "file_2_name"
"version3Release" → kebab-case → "version-3-release"
"user123profile" → camelCase → "user123Profile"

3. Unicode Handling

Non-ASCII characters add complexity. Key edge cases include:

• German ß: Uppercases to "SS" in most contexts ("straße" → "STRASSE")
• Turkish İ/i: Lowercase "I" is "ı" in Turkish, "i" in English
• Greek: Final sigma (ς) vs. medial sigma (σ) when lowercasing
• Ligatures: "fi" (U+FB01) should expand to "fi" for splitting

The Prescosoft case converter tool uses Unicode-aware processing to handle these cases correctly without requiring locale configuration from the user.

4. Title Case Intelligence

Title Case isn't simply "capitalize every word." Standard rules keep certain words lowercase:

• Articles: a, an, the
• Coordinating conjunctions: and, but, or, for, nor
• Short prepositions: in, on, at, to, by, of, up

But the first and last words are always capitalized regardless of their part of speech. A proper title case converter applies these rules automatically.

"the quick brown fox jumps over the lazy dog"
→ "The Quick Brown Fox Jumps over the Lazy Dog"
    (articles/prepositions lowercase, first/last word capitalized)

5. Abbreviations and Acronyms

Acronyms like "JSON", "API", and "HTML" should remain uppercase in most conversions. When converting to snake_case, they become "json_api_parser" not "j_s_o_n_a_p_i_parser". Smart converters preserve recognized acronyms as single tokens during word splitting.