89 Tips to help you be a better coder and write clean code in 2022
89 Tips to help you be a better coder and write clean code in 2022
Writing clean code is a must for any developer. Here are 89 tips to help you be a better coder and write clean code in 2022 from 'Clean code' by Robert C. Martin.
General rules
- 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.
Design rules
- 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.
Understandability tips
- 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 type.
- Avoid logical dependency. Don't write methods that work correctly depending on something else in the same class.
- Avoid negative conditionals.
Names rules
- Choose descriptive and unambiguous names.
- Make meaningful distinctions.
- Use pronounceable names.
- Use searchable names.
- Replace magic numbers with named constants.
- Avoid encodings. Don't append prefixes or type information.
Functions rules
- Small.
- Do one thing.
- Use descriptive names.
- Prefer fewer arguments.
- Have no side effects.
- Don't use flag arguments. Split the method into several independent methods that can be called from the client without the flag.
Comments rules
- 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 the code. Just remove.
- Use as an explanation of intent.
- Use as clarification of code.
- Use as a 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 closed.
- 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 ones.
- 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.
- A small number of instance variables.
- Base classes 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.
Tests
- One assert per test.
- Readable.
- Fast.
- Independent.
- Repeatable.
Refactoring
- Make the change easy, then make the easy change.
- Don't be afraid to throw code away.
- One level of abstraction per function.
- Switch statements.
- Use descriptive names.
- Remove dead code.
- Don't use flags.
- Eliminate side effects.
- Extract functions.
Error handling
- Use exceptions.
- Use unchecked exceptions.
- Don't return error codes.
- Don't pass error codes.
- Don't ignore errors.
- Don't ignore exceptions.
- Don't catch generic exception.
Concurrency
- Don't share state between threads.
- Encapsulate state into objects.
- Don't pass mutable data to a thread.
- Avoid excessive locking.
- Prefer immutable data structures.
- Prefer executors, tasks, and streams to threads.
- Prefer concurrency utilities to wait and notify.
Code smells
- 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 the involved risks and high effort.
- Needless Complexity.
- Needless Repetition.
- Opacity. The code is hard to understand.
Comments
Post a Comment