Robert Martin (Uncle Bob) once said,
"Any fool can write code that computers understand. Good programmers write code that humans can understand"
Many of us take pride in ourselves when we provide a solution and write code for a complex problem, but what makes you a complete developer when you write code which your fellow developers can easily understand and giving meaningful names to the variables, functions and classes plays a vital role in that.
Let me tell you why?
I did understand this principle of clean code after a few years into professional coding when I struggled to understand my own code written just a few months ago. You must have us gone through a situation where you would like to prefer writing a fresh code for a bug fix or changes in the requirements instead of incorporate changes to existing code of other developers. These codes are technical debts to the team and organization and if you are also one of them who does not put deliberate effort to keep your code clean and followed the principles of clean codes, someone else down the line reading your code will feel the technical debt you have written that will increase the burden for maintainability, scalability and code debugging.
Providing meaningful names is one of the many principles of clean code and I feel providing meaningful names is the most important one.
Here are the rules for providing meaningful names
Naming Classes:
One class should carry only one responsibility. Hence this intent should reflect through the class name. A good rule of thumb while naming classes and methods is to think of nouns while naming class and verbs while naming methods.
Not Clean
Builder
Processor
WebsiteBO
Utility
Above class names do not tell what specific single responsibility it holds and hence becomes magnet class for other developers as they shove other responsibilities to these classes.
Clean
User
QueryBuilder
ProductRepository
Naming Method:
By method name reader should understand what is there inside the method and should have only one job to do.
Not Clean
send()
get()
export()
Clean
sendMail()
getValidUser()
exportZipFile()
Not Clean
//Code 1
Public Boolean sendSuccessMail( User user){
If(user.status == STATUS.active &&
isValidUserMail(user.mail)){
//code for generating emailId,subject and email body
MailUtils.sendMail(mailId,subject,body);
}
}
```
code 1 breaks 2 rules of clean code. It not only performs two responsibilities and but also its name does not indicate its jobs clearly. Which may cause lots of problem in future.
Let's look at the better version but still not clean
```
Code 2
Public Boolean checkValidUserAndSendSuccessMail( User user){
If(user.status == STATUS.active && isValidUserMail(user.mail)){
//code for generating emailId,subject and email body
....
MailUtils.sendMail(mailId,subject,body);
}
}
```
Code 2 with method name `checkUserAndSendSuccessMail` is somewhat better in terms of clear intent, but it still carries more than one responsibility which is not good for code reusability and codebase may end up with many duplicate codes and in many places, you may need different logic for user validation or only mail send. And if there is any change in user validation code, it will not only impact user validation test cases but also send mail test cases.
Clean Code
```
Public Boolean checkValidUser ( User user){
return user.status == STATUS.active &&
isValidUserMail(user.mail)
}
Public Boolean sendSuccessMail( User user){
//code for generating emailId,subject and email body
...
MailUtils.sendMail(mailId,subject,body);
}
Boolean isValidUser = checkValidUser(user);
If(isValidUser){
sendSuccessMail(user)
}
```
`Warning signs for methods carrying multiple jobs: AND, OR, IF etc
Avoid Abrr like isUsrRegis, regisDone`
***Naming Boolean variable:***
Boolean variable should always ask questions and should be symmetrical when used in pair.
Not Clean
```
send
complete
close
login
open/completed
```
if you declare these kinds of variable, the reader will face problem to understand the use of these variables later in code something like `if(login == true)`
Clean
```
loggedIn
isMailSent
isValidationDone
closed
open/close (symmetric)
```
***Conditions:***
Write implicit code around boolean variables
Not Clean
```
If(isValidationDone == true)
```
Clean
```
if( isValidationDone)
```
Not Clean
```
Boolean isEligibleforDiscount;
If(purchaseAmount >3000){
isEligibleforDiscount = true;
}else{
isEligibleforDiscount = false
}
```
Clean
```
Boolean isEligibleforDiscount = purchaseAmount >3000;
```
Use positive conditions
Not Clean
```
If(!isUserNotValid)
```
Clean
```
If(isValidUser)
```
User ternary operator
Avoid using “stringly-typed”/”hard-coded” value
Not Clean
```
If(process.status == “completed”)
```
Instead of stringly typed value, we can use Enums and keep all the status of the process in a single place and we can get rid of typos with strongly typed and help maintain code base with a single place to change.
Avoid using magic numbers
Not Clean
```
If( employee.yearsWorked > 10){
}
```
replace constant or enums with magic number
Clean
```
Int promotionEligibleYears = 10;
If(employee.yearsWorked > promotionEligibleYears)
```
>“Programming is the art of telling another human what one wants a computer to do” — Donal Knuth
For more knowledge on the clean code principles, you can go through below listed resources
***References & Resources:***
[Clean Code: Writing Code for Humans](https://www.pluralsight.com/courses/writing-clean-code-humans)
[Clean Code: A Handbook of Agile Software Craftsmanship (Robert C. Martin)](https://www.amazon.in/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882)
Follow me [Twitter](https://twitter.com/imimtiyaz9) [Linkedin](https://www.linkedin.com/in/md-imtiyaz-ahmed-092a6597/)
Top comments (5)
Great post mate! I've one suggestion, I usually use the "get" as method name when it represents the class name data, it makes the method calling more elegant, for example:
User.get()instead
User.getUser()Thanks Alisson fo reading..
There is no problem when you use get() method with Class or object. it will reflect the intent that activeUser.get() means method is calling for an active user. But you can't be sure that get() method will be used always like that, for example, it can be used like this.get() or simply get(). Since you have created the method you may always use with some object or Class, but how will other developers know that and they make a mistake of unclean code while using such existing methods.
Thanks. Inspired me to write a Devopedia article on Clean Code. BTW, the last quote is from Donald Knuth.
Thanks Arvind for pointing out the typo. Will update that.
Thank you for the post. The Javascript version for "Clean Code" is here which I have been going through recently