Latest news about Bitcoin and all cryptocurrencies. Your daily crypto news habit.
We can all write code and make stuff work but when we look back at our own code, we realize how bad it was and how far we have come. Good, you are already evolving. but this series will take your learning up a notch and make it even better.
Sometimes code can become a mess and the cost of owning a big mess can be huge. Developers fear from making new changes as it might break something else. How can we solve that?
The answer is clean code. It means that the code should be simple enough to understand and make further changes without fear of breaking something else. i.e readable and maintainable. It requires you to give extra care and time while writing the code but its beneficial in the long run because a software is never complete and changes with time. so lets jump to how YOU can write clean code.
Meaningful Names
Any name? No. You are not writing the code for yourself. you are writing the code for others so when your team or your future self reads the old code. They donât pull their hairs trying to figure out what it does and unintentionally wasting their time. Code consists of a lot of variables, classes and Methods. and everything has a name. the names need to be consistent and explain what the code does. Some examples of consistent names can be found here. Letâs look at an example:
int m; // elapsed time in minutes
The name m reveals nothing. It does not evoke a sense of elapsed time, nor of days. We should choose a name that specifies what is being measured and the unit of that measurement:
int elapsedTimeInMinutes;
This makes the variable easy to understand and reveal its exact purpose. we donât even need to write extra comments as the code is self explanatory.
Lets take a look at another method:
The method name getThem gives us no idea what the method does. someone using that method has to go inside that method and go thorough the whole code to understand what it does.now we refactor the below code to:
This is the same code as above but the name getEvenNumbers gives us clear idea what it does and we donât have to go inside the code to see what it does. With these simple name changes, itâs not difficult to understand whatâs going on. This is the power of choosing good names.
Meaningful arguments
consider below code:
And compare with:
Notice the difference in readability of both methods? now we know what argument is being used for what purpose just by the signature of method.
Use Pronounceable names
One should not use any non standard abbreviations that may confuse others. using no instead of number is tolerable as everyone knows what it means.( I do not encourage this as it may get confused by âNOâ) but we should not create our own abbreviations which might confuse someone else. such as while writing dates a variable called Date creationTimestamp; is better than Date creationdmY; as the former can be pronounced in a conversation.
Use Searchable Names
One might easily grep for MAX_CLASSES_PER_STUDENT, but the number 7 could be more troublesome. Searches may turn up the digit as part of file names, other constant definitions, and in various expressions where the value is used with different intent.
Once again compare
to
now the code is more searchable in case any change need to be done.
Use Proper spellings
Proper Spellings are also a part of making things searchable. a simple misspelling of a word Hierarchy to Heirarichy can make that world impossible to find in the whole codebase.
Method Names
Methods should have verb or verb phrase names like postPayment, deletePage, or save. Accessors, mutators, and predicates should be named for their value and prefixed with get, set, and is according to the javabean standard.
Address address= person.getAddress(); if (address.isCity())âŠ
When constructors are overloaded, use static factory methods with names that describe the arguments. For example,
Complex fulcrumPoint = Complex.FromRealNumber(23.0);
is generally better than
Complex fulcrumPoint = new Complex(23.0);
Use Solution Domain Names
People who read your code are still programmers so you can still use some domain specific terms. The name MainActivity means a lot to a person familiar with android. which programmer would not know what a Map is in programming terms?
Conclusion
The hardest thing about naming things that it may take time sometimes and varies with personal cultural background. Most of the time we donât memorize the names instead we use modern IDEs to search and find them. Follow some of these rules and see whether you donât improve the readability of your code. If you are maintaining someone elseâs code, Modern IDEs has made is very easy to refactor things. It will pay off in the short term and continue to pay in the long run.
The Principles in this post are taken from a book I read recently, Clean Code: A Handbook of Agile Software Craftsmanship. I highly recommend that you should read it if you want to dive even deeper.
If you enjoyed this story, please click the đ button and share to help others find it! Feel free to leave a comment đŹ below.Have feedback? Letâs be friends on Twitter. The next part will have clean functions, Stay tuned. Until then keep clean coding đ
How to be a Clean Coder (Part 1) was originally published in Hacker Noon on Medium, where people are continuing the conversation by highlighting and responding to this story.
Disclaimer
The views and opinions expressed in this article are solely those of the authors and do not reflect the views of Bitcoin Insider. Every investment and trading move involves risk - this is especially true for cryptocurrencies given their volatility. We strongly advise our readers to conduct their own research when making a decision.