camelCase gets its name from the way the capitalized letters within a word resemble the humps of a camel. In camelCase, the first letter of the first word is always lowercase, and the first letter of every subsequent word is uppercase. No spaces or underscores are used.

camelCase is the dominant convention in JavaScript and TypeScript for variable names, function names, and object properties. It's also standard in Java for variable and method names, and in many JSON API response formats.

• ▸myVariableName
• ▸getUserById
• ▸fetchApiResponse
• ▸handleButtonClick
• ▸isUserLoggedIn

PascalCase (also called UpperCamelCase) follows the same 'no spaces, capitalize word boundaries' rule as camelCase — but the very first letter is also capitalized. Every word, including the first, starts with an uppercase letter.

PascalCase is the standard for class names and constructor functions in most languages. In C#, PascalCase is used for virtually everything public — classes, methods, properties, and namespaces. In React, component names must use PascalCase (otherwise React treats them as HTML elements and won't render them).

• ▸MyClassName
• ▸UserService
• ▸FetchApiResponse
• ▸ButtonClickHandler
• ▸NavigationMenu

JavaScript and TypeScript: variables, functions, and object properties use camelCase. Classes, React components, TypeScript interfaces, and type aliases use PascalCase. Constants use CONSTANT_CASE.

C#: everything public uses PascalCase — methods, properties, classes, namespaces. Private fields commonly use _camelCase with an underscore prefix.

Python: variables and functions use snake_case, but class names use PascalCase. Constants use UPPER_SNAKE_CASE. This mix of conventions across different identifier types is standard PEP 8 style.

Java: variables and methods use camelCase, class names use PascalCase, and constants use UPPER_CASE_WITH_UNDERSCORES.

In React, this is not just a convention — it is a functional requirement. React uses the capitalization of a component name to decide how to handle it at runtime.

Writing <userCard /> tells React to look for a standard HTML element called 'usercard'. It will not find one and the component simply will not render. Writing <UserCard /> tells React this is a custom component, and it renders your code correctly.

This is why every React component name — function components, class components, and higher-order components — must start with an uppercase letter. It is one of the rare cases in programming where a casing mistake causes a silent rendering failure rather than an error.

Use camelCase for: variables and constants (JS/TS/Java), function and method names (JS/TS/Java), object properties and JSON keys, React hook names (useEffect, useState), private class fields.

Use PascalCase for: class definitions in any language, React component names, TypeScript interfaces and type aliases, C# public members, Python class names, constructor functions.

When you're unsure: if it's a value or a behavior (something that holds data or does something), reach for camelCase. If it's a blueprint or a type (something that defines structure), reach for PascalCase.