When you start learning how to code your main focus is writing code that works correctly for the problem you are solving. Yes, code needs to work correctly and that is a good place to start learning. However, in a real work environment, you also want to ensure you write clean code. Clean code is readable, extensible, changeable, and maintainable. These are all important qualities for a codebase to have. In many professional settings, you are not writing code in complete isolation. There are other people you work with on a team. Your teammates need to be able to easily understand the code you write. They need to understand what it does, how it works, and why it was written that way. It may also be your future self coming back to code you wrote in the past and you will also need to easily understand your code. Code is read more than it is written. To write code we are constantly reading it. So even if readable code is harder to write we should invest time to do it instead of writing easy unreadable code. Writing clean code is an important skill for any professional developer. In this article, we are going to learn about the importance of in writing clean code. Naming Naming is a crucial and daily task for developers in any programming language. It can either make code very hard to understand or if done well, easy to understand. Names are all over the software developers write. When coding, you should consider naming variables, functions, arguments, classes, packages, source files, and directories that contain those source files, etc. Below are some popular quotes on naming in programming. “There are only two hard things in Computer Science: cache invalidation and naming things.” - Phil Karlton “Any fool can write code that a computer can understand. Good programmers write code that humans can understand” — Martin fowler Names are the smallest building block of code. Names are the basic building block of clean code. There are some recommended rules for good naming in code. Let us discuss these rules for the rest of this article. Use intention revealing names The names you use in your code must be clear and understandable. Choose descriptive and unambiguous names. You should focus on the . Aim to write code that other people would expect and try not to surprise them with some clever complexities. principle of least surprise The name of a variable, function, or class, should answer all the big questions. It should tell you why it exists, what it does, and how it is used. If a name requires a comment, then the name is not intention revealing. Below is an example of code that is not intention revealing because it requires a description comment. Just below it, you'll find a cleaner version with better naming that does not require a description comment. let rf = 5000 //the rental fee paid by the tenant use the cleaner version below let rentalFee = 5000 Classes and objects should have noun or noun phrase names Classes and objects describe things so their names in code should be a noun or noun phrase. Names such as User, Student, Account, and ErrorLogger are good names for classes and objects. Avoid words like Manager, Processor, Data, or Info in the name of a class. A class name should not be a verb. Methods/Functions should have verb or verb phrase names Methods/Functions perform an action in the code so their names should be a verb or verb phrase. Names such as , , or are good names for methods/functions. By design, a function should have only one responsibility. If the name is anything other than a verb, then either you are naming it wrong or there are some problems in the architecture. deleteApplication createUser save Make meaningful distinctions You should try to use the same word for the same purpose across the codebase. Avoid using different but similar words to define the same concepts. For example, the three method/function calls below could mean the same thing. FetchResult() vs GetResult() vs RetrieveResult() Don’t use , and in the same project for the same responsibility. fetch get retrieve Use pronounceable and searchable names When naming things in your code use words that can be pronounced rather than using non-pronounceable words. Below is an example of a variable name that is not easily pronounceable and a cleaner version with a more pronounceable name. Date modymdhms; use the cleaner version below Date modificationTimestamp; Replace magic numbers with named constants When you are using some constant values define them using searchable words. It makes them more understandable to other developers. Instead of writing code like this: let totalLoanDays = gracePeriod + 7; create a named constant and use it like this: const NUMBER_OF_DAYS_IN_WEEK = 7; let totalLoanDays = gracePeriod + NUMBER_OF_DAYS_IN_WEEK; Don’t append type information When you name your variables avoid appending type information to them. It should be clear from the name of the variable what data it stores and developers can infer the type from there. There is no need to mention the data type in the name. Instead of writing code like this: let firstNameString; let lastNameString; Use the cleaner version below: let firstName; let lastName; Don’t Be Offensive / Don’t Be A Comedian Remain professional in how you name things in your code. Do not be offensive or try to be a comedian by giving a variable a funny name. Remember, you are writing production code that other software developers will need to understand easily in the future. Your naming conventions should be generic and should not include any cultural slang. Avoid writing code like this: function killThemAll(); use the cleaner and professional version below function deleteAllUsers(); Closing thoughts In this article, we have explored some of the best practices for naming things in your code, and some things you should avoid doing. Naming may appear to be a small part of a software developer’s job but it is very important and can be the main difference between having a clean codebase that is a joy to work with or a complex codebase that is difficult to understand and navigate. "One difference between a smart programmer and a professional programmer is that the professional understands that clarity is king. Professionals use their powers for good and write code that others can understand." You should never ignore the importance of naming practices in your codebase as bad names will become a big hurdle in future development plans. Changing the codebase at that point is unnecessary overhead and can be avoided in the very beginning by following good practices. The New Developer This article was originally published on . Head over there if you like this post and want to read others like it. The New Developer References/Resources: Clean Code: A Handbook of Agile Software Craftsmanship by Robert C Martin.

Fetch

How To Ask For Feedback As a New Software Developer

11 Books Every Software Developer Should Read

If you want to learn about how to become a better software engineer - join my Substack newsletter.

Writing clean code: Naming

About Author

Comments

TOPICS

THIS ARTICLE WAS FEATURED IN

Related Stories

Untitled Story

Why Communication is Important for Software Developers

5 Essential Software Architecture Design Principles

A Beautiful Architecture of Server-Side Alarm

A Deeper Look into Clean Architecture: Flutter vs Kotlin

An Introductory Guide to Monolith Software Applications

Why Communication is Important for Software Developers

5 Essential Software Architecture Design Principles

A Beautiful Architecture of Server-Side Alarm

A Deeper Look into Clean Architecture: Flutter vs Kotlin

An Introductory Guide to Monolith Software Applications

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps