If you are mildly interested in programming, you already know camel case is the most common naming convention for identifiers in programming languages. In modern times, brands and social media platforms started to use this concept for its increased readability and aesthetic looks. But how come such a small change in a single letter of a sentence makes such a big difference?
It is easy to see why this is important in the programming language. We need every possible way to simplify what is already a very complicated language. Although applications like Copilot have made coding easier for us, it can be difficult to read long lines of code. That’s where we take the helping hand of the camel casing. By changing a letter to upper case, a line in a code can be a lot easier to read.
The same goes for branding actually. A lot of brands use this trick to emphasize a product or a feature in their catalogs so that users can get a better and easier understanding of it. For example, the tech giant Apple has been applying camel casing for their products for years. The ”iPhone”, ”iMac”, ”MacOS”,” AppleWatch” are just a few examples of them.
So what effect does camel casing have on the human brain and how does it manage to be so effective? Let us explain it for you.
Camel casing gets its name from a camel’s hump (Image credit)
What is a camel case?
Camel case is a naming convention for identifiers in programming languages, variable names, and function names. It is characterized by the use of capital letters at the beginning of each word in a compound word, without any spaces between the words. For example, “camelCase”, “iPhone”, and “myVariable” are all camel case identifiers.
Camel casing was first used in the programming language Modula, which was created by Niklaus Wirth in the 1970s. It was later adopted by other programming languages, such as Pascal, C, and Java. Today, camel casing is the most common naming convention for identifiers in most programming languages.
There are two main types of camel case:
- Upper camel case (also known as Pascal case): This is a variation of camel case where the first letter of each word in a compound word is capitalized, including the initial letter of the first word. For example, “PascalCase”, “MyVariable”, and “GetUserName” are all upper camel case identifiers
- Lower camel case (also known as dromedary case): This is a variation of camel case where the first letter of the first word in a compound word is lowercase, and the first letter of each subsequent word is capitalized. For example, “camelCase”, “myVariable”, and “getUserName” are all lower camel case identifiers
Camel casing is used in programming languages because it makes it easier to read and write code. It also helps to prevent errors, such as typos and name collisions.
In addition to programming languages, camel casing is also used in other contexts, such as:
- Web URLs: For example, the URL “https://www.google.com/” is in camel case
- Computer naming conventions: For example, the computer name “MyDesktopComputer” is in camel case
- Product names: For example, the product names “iPhone” and “iPad” are in camel case
- Brand names: For example, the brand names “YouTube” and “FedEx” are in camel case
A golden standard for programming
Camel case is a naming convention that combines words by making the first letter of each word capitalized, with no spaces between the words. It is commonly used in programming and computer naming conventions, as well as in web URLs.
There are a few reasons why Camel case is a good choice for naming variables, functions, and other code elements:
- It makes code more readable and easier to understand. By combining related words into a single term, Camel case makes it easy to see what the code is doing at a glance
- It reduces the amount of typing required. Camel case is more concise than other naming conventions, such as snake case, which uses underscores to separate words
- It makes it easier to spot typos and errors. Camel case makes it more obvious when a word is misspelled or when two words are accidentally combined
Camel case is preferred by many programmers for its readability and conciseness (Image credit)
Why camel case is essential for programmers?
Camel case is essential for programmers because it makes code more readable and maintainable. When code is well-written and easy to read, it is easier to understand, debug, and modify. This is especially important for large codebases that are worked on by multiple developers.
Camel casing also helps to ensure consistency in code style. When all developers on a team follow the same naming conventions, the code becomes more readable and predictable. This can help to reduce errors and make it easier for new developers to contribute to the codebase.
Here are some examples of camel casing in programming:
// Variable names
var myFirstVariable;
var mySecondVariable;
var myThirdVariable;
// Function names
function calculateTotal() {
// …
}
function displayResults() {
// …
}
// Class names
class MyClass {
// …
}
As you can see, camel casing is a simple but effective naming convention that can make a big difference in the readability and maintainability of code. It is advised for programmers to use camel casing whenever possible to make their code easier to read, understand, and modify.
How camel case influences readability?
There is a growing body of scientific evidence to suggest that camel case can improve readability. For example, a 2009 study by Binkley et al. found that participants were more accurate at recognizing and understanding camel case identifiers than snake case (underscore) identifiers. The study also found that participants were faster at recognizing camel case identifiers after training.
Another study, conducted by Maletić et al. in 2010, found that camel case identifiers led to higher accuracy and lower visual effort when compared to snake case identifiers. The study also found that participants with more experience in programming were faster at reading camel case identifiers.
The scientific explanation for why camel casing improves readability is based on the way that the human brain processes language. When we read text, our brains automatically group words together into meaningful phrases. This process is known as lexical chunking.
Camel casing makes it easier for the brain to group words together because it removes the spaces between words. This allows the brain to quickly recognize the different words in a phrase and understand their meaning.
In contrast, snake case identifiers can make it more difficult for the brain to group words together because the underscores break up the words into individual chunks. This can lead to slower reading and reduced comprehension.
In addition to the scientific evidence, there is also a strong consensus among programmers that camel case improves readability. Camel case is the preferred naming convention for most programming languages and is widely used in codebases all over the world.
Camel case vs Pascal case vs Snake case
Camel case is the most common naming convention in programming. It is easy to read and write, and it makes it easy to see the relationship between words in a compound name. Camel casing is also compatible with most programming languages, which makes it a good choice for cross-platform development.
Pascal case is less common than camel casing, but it is still widely used in some programming languages, such as Java, C#, and TypeScript. Pascal case is often used for class names, interface names, and namespace names because it makes them stand out from other code elements.
Snake case is commonly used in programming languages like Python and Ruby. It is also used for database table and column names in some operating systems. Snake case is easy to read and write, and it makes it easy to see the relationship between words in a compound name. However, snake case can be more difficult to read and write in long compound names.
Scientific studies have shown that camel case enhances readability and comprehension compared to other naming conventions like snake case (Image credit)
Here is a more detailed comparison of the three naming conventions:
| Naming convention | Pros | Cons |
|---|---|---|
| Camel case | Easy to read and write, compatible with most programming languages | Can be difficult to distinguish between words in long compound names |
| Pascal case | Makes class names, interface names, and namespace names stand out from other code elements | Less common than camel case |
| Snake case | Easy to read and write, makes it easy to see the relationship between words in a compound name | Can be more difficult to read and write in long compound names |
Not just limited to programming
As we mentioned before, camel casing is not only used in programming languages. It is also used in other contexts such as branding, web URLs, and computer naming conventions. The use of camel casing in these contexts helps to improve readability and make it easier for users to understand and remember names and identifiers.
