We do programming to solve problems. Unaware of the mind, We often write bad code to get things done faster. And when the changes come, that time we realize how bad our code is. As a human being, just as you have to sleep every day, a programmer must accept that the client's requirements must changes. There are many programmers who are upset when a client’s requirements are changed and cannot easily accept the change. The reason programmers are upset that they wrote bad code past in that project.
In order to write good code, we need to know which is bad code. I’ve created a definition of bad code. The definition is:
A bad code is when a programmer or coder do program to get things done faster without thinking much about future changes and ignoring the possibility of other developers touching the code.
First, we need to know what a bad code really is? I’m giving you some possible reasons for the bad/poor code
- Hard to read and understand: The first characteristic of bad code is that nobody else understands it fast. That means when a developer try to update your code he/she need to put extra time for understanding your code. And finally, if he understands your code he will have trouble adding any new ones. Many times new developers lose jobs because they do not understand the old code. Many times developers leave their jobs because of the existing messy or bad code.
- It contains many levels of nested blocks like if-else statements, loops: Developers often use nested blocks like if-else statements, loops to get the desired result quickly. And when the program successfully compiled, developers forgot to optimize the program.
- Poorly named methods and variables: To save time, we often use the variable /method name lIke X, Y, Z or ABC. That is very bad. When you do programming, you might remember what this XYZ works for. But after a few days when you are going to update this same code again or someone else updates your code, No One can understand the meaning of the variable/method name.
- Unnecessary code comments: Adding many redundant comments trains the reader to skip over every comment, so when there is a comment that is important it will likely not be read.
- Some other reasons:
- There are very less or no logical separations and everything is written in a single method.
- The classes are highly coupled and even a small change in the code may require changing many other parts of the system.
Programmers write Bad Code due to many reasons but the most commons are:
- Meeting the deadlines in a fast-paced project.
- Unawareness about code quality and best coding practices.
- Carelessness, i.e. taking shortcuts, not thinking much about future changes.
If you want to avoid bad code and write clean code, you must read Robert C Martin’s Clean Code. According to his book…
Code is clean if it can be understood easily — by everyone on the team. Clean code can be read and enhanced by a developer other than its original author. With understandability comes readability, changeability, extensibility and maintainability.
Here is the summary of Clean Codes. If you follow the rules, Your code will be clean and understandable.
- Follow standard conventions.
- Keep it simple stupid. Simpler is always better. Reduce complexity as much as possible.
- Boy scout rule. Leave the campground cleaner than you found it.
- Always find the root cause. Always look for the root cause of a problem.
- Keep configurable data at high levels.
- Prefer polymorphism to if/else or switch/case.
- Separate multi-threading code.
- Prevent over-configurability.
- Use dependency injection.
- Follow the Law of Demeter. A class should know only its direct dependencies.
- Be consistent. If you do something a certain way, do all similar things in the same way.
- Use explanatory variables.
- Encapsulate boundary conditions. Boundary conditions are hard to keep track of. Put the processing for them in one place.
- Prefer dedicated value objects to a primitive types.
- Avoid logical dependency. Don’t write methods that work correctly depending on something else in the same class.
- Avoid negative conditionals.
- Choose descriptive and unambiguous names.
- Make a meaningful distinction.
- Use pronounceable names.
- Use searchable names.
- Replace magic numbers with named constants.
- Avoid encodings. Don’t append prefixes or type information.
- Do one thing.
- Use descriptive names.
- Prefer fewer arguments.
- Have no side effects.
- Don’t use flag arguments. Split method into several independent methods that can be called from the client without the flag.
- Always try to explain yourself in code.
- Don’t be redundant.
- Don’t add obvious noise.
- Don’t use closing brace comments.
- Don’t comment out code. Just remove.
- Use as explanation of intent.
- Use as clarification of code.
- Use as warning of consequences.
Source code structure
- Separate concepts vertically.
- Related code should appear vertically dense.
- Declare variables close to their usage.
- Dependent functions should be close.
- Similar functions should be close.
- Place functions in the downward direction.
- Keep lines short.
- Don’t use horizontal alignment.
- Use white space to associate related things and disassociate weakly related.
- Don’t break indentation.
Objects and data structures
- Hide internal structure.
- Prefer data structures.
- Avoid hybrids structures (half object and half data).
- Should be small.
- Do one thing.
- Small number of instance variables.
- Base class should know nothing about their derivatives.
- Better to have many functions than to pass some code into a function to select a behavior.
- Prefer non-static methods to static methods.
- One assert per test.
- Rigidity. The software is difficult to change. A small change causes a cascade of subsequent changes.
- Fragility. The software breaks in many places due to a single change.
- Immobility. You cannot reuse parts of the code in other projects because of involved risks and high effort.
- Needless Complexity.
- Needless Repetition.
- Opacity. The code is hard to understand.
Buy Clean Code: https://amzn.to/3cfeCoQ