In programming, typographic conventions aren’t just about the style and appearance of your code. On the contrary, they play a crucial role in making code readable, maintainable and consistent. By following the most popular naming conventions and established typographic styles, developers can more clearly communicate the purpose and scope of variables, functions, and classes. This makes it easier to understand the code at a glance, especially when working collaboratively.

Hello, my name is CyCoderX and in this article we will explore common typographic conventions such as Camel Case, Snake Case and Pascal Case, as well as less common styles like Hungarian notation. Each convention has its own purpose and typical use case, and knowing when to apply them can make your code more professional and accessible to others.

Let’s go!

I write articles for everyone’s enjoyment and would love your support by following me for more Python, SQL, Data Engineering and Data Science content.😊

Starting with the most famous naming convention Camel affair. Camel Case is a naming convention in which each word in a compound term begins with a capital letter, except for the very first word. Pretty simple, right?

This style is very popular in many programming languages, including JavaScript and Java, where it is used for variable and function names. The first lowercase letter followed by uppercase letters for each subsequent word creates a “camel hump” effect haha.

How is the Camel case used:

• Example: camelCaseExample, totalPrice, calculateTotal
• Common use: Camel Case is frequently used for variables and functions in languages ​​like JavaScript, Java and Swift.

Camel Case improves readability without the need for underscores or other delimiters, helping developers recognize every word in the name.

Another very popular naming convention and the one I use is Serpent affair. Snake Case separates words in a name with underscores, making it easy to read while keeping the letters lowercase.

This convention is widely used in languages ​​like Pythonwhere it is considered the standard for naming functions and variables.

How the Snake Case is used:

• Example: snake_case_example, total_price, calculate_total
• Common use: In PythonSnake Case is the preferred style for naming variables and functions. It is also often used in configuration files and data serialization formats like JSON.

Snake Case is particularly readable, making it ideal for long variable names and scenarios where readability is a priority, such as data science scripts and machine learning code.

Pascal case is similar to Camel Case, but in Pascal Case, each word — including the first — begins with a capital letter. This convention is often used to name classes, especially in languages ​​like C# and Javawhere it helps distinguish class names from other identifiers.

How the Pascal case is used:

• Example: PascalCaseExample, TotalPrice, CalculateTotal
• Common use: Pascal Case is typically used for class names in languages ​​like C#, Java, and TypeScript, following the convention that class names should stand out from variables and functions.

Pascal Case makes it easy to recognize class names at a glance, adding a layer of clarity to object-oriented code by indicating that the name represents a class or module.

I’m not kidding. There is a name conversion called Kebab affair. Kebab Case is a naming style in which words are separated by hyphens instead of underscores or capital letters. It’s called “kebab” because the hyphens look like kebab skewers. This convention is mainly used in web development, especially for CSS classes and identifiers.

How the Kebab case is used:

• Example: kebab-case-example, total-price, calculate-total
• Common use: Kebab Case is primarily used in HTML and CSS, where it is common for naming classes or identifiers. You’ll often see this in web frameworks and static site generators.

Since many programming languages ​​do not allow hyphens in variable names, Kebab Case is less common outside of HTML and CSS. However, it is a widely recognized style in web development that makes CSS selectors easy to read.

Join my LinkedIn group to connect with like-minded professionals and stay ahead of industry trends!

Hungarian notation is a convention that prefixes variable names with one or more letters indicating the data type or purpose of the variable. Although less popular in modern programming, Hungarian notation was widely used in early programming languages ​​and still appears in some code bases, particularly in embedded systems or low-level code.

How Hungarian notation is used:

• Example: strName (chain), iCount (entire), bIsActive (boolean)
• Common use: Historically used in the C and C++ codebases, Hungarian notation can sometimes be found in applications where variable types must be distinguished at a glance. It is also used in some older Visual Basic and WinAPI code.

Although Hungarian notation can improve readability in contexts where type information is not obvious, it is generally not recommended for modern code due to the redundancy it introduces, particularly in typecast languages. static where the types are already defined.

SCREAMING_SNAKE case – sometimes simply called “All Caps” – is a variation of Snake Case where all letters are capitalized. This convention is used primarily for constants or values ​​that must remain unchanged throughout the program, making them visually distinguishable from other variables.

How the SCREAMING_SNAKE case is used:

• Example: SCREAMING_SNAKE_CASE_EXAMPLE, MAX_SIZE, DEFAULT_COLOR
• Common use: In Python, SCREAMING_SNAKE Case is often used for global constants, making it easier to identify fixed values ​​at a glance. It is also used in Java and other languages ​​to indicate constants and environment variables.

By distinguishing uppercase constants, SCREAMING_SNAKE Case signals to other developers that these values ​​are intended to be immutable and global, helping to avoid accidental modification.

Typographic conventions in programming are more than just stylistic choices: they improve the readability, maintainability, and clarity of code. Congresses like camel case And Pascal case help distinguish variables, functions and classes, while Snake case And SCREAMING_SNAKE case add clarity to constants and global values. Understand and use conventions like Kebab case in CSS or Hungarian notation For type clarity, we ensure our code follows established standards, making it easier for teams to collaborate and reducing the learning curve for new developers joining a project.

By consistently applying these naming conventions, we can make our code more intuitive and readable for ourselves and others. Every convention has its ideal application, and choosing the right one not only keeps the code organized, but also effectively communicates the purpose and scope of each identifier. In any programming environment, knowing and following these conventions makes a significant difference in the quality and professionalism of the code.

Happy coding!

Thank you for taking the time to read my article.
This article was first published on Medium by CyCoderX.

Hi, my name is CyCoderX! I am a data engineer passionate about sharing knowledge, I write articles on Python, SQL, Data Science, Data Engineering and many more!

What did you think of this article? Let me know in the comments below…or above, depending on your device!

1. Clapping 50 times for this story
2. Leave a comment telling me what you think
3. Highlight your favorite part of the story
4. Connect with me on LinkedIn and join my LinkedIn group

Thank you for reading to the end. Before leaving: