10 practices from over 30 years of coding experience

So, how to write good code?

Good code is easier to read, understand, debug, and modify, and most importantly, it has fewer defects. Obviously, writing good code takes more time, but it also has more value in the long run because it reduces maintenance costs and has better reusability.

In fact, we can equate good code with reusable code, which is the driving principle behind many of the tips listed in this article. As a developer who wants to implement a specific function, the code may achieve your short-term goals, but if no one else wants to reuse it (including your future self), the code must be missing something. Whether it is too complex or too specific, there is a high chance that it will be wrong or not trusted by other developers in different situations.

I’ve found that if you simply try to consistently apply the best practices below to all the code you write (including your experiments and prototypes), you’ll write better code no matter what your current experience level is.

1. Follow the single responsibility principle

Functions are the most important form of abstraction in a programmer's toolkit. The more they are reused, the less code you have to write, and the more reliable your code becomes. Smaller functions that follow the single responsibility principle are more likely to be reused.

2. Minimize shared state

You should minimize implicit shared state between functions, whether it's file-scope variables or object fields, in favor of explicitly requiring values ​​as parameters. Code becomes easier to understand and reuse when it's clear what a function needs to produce the desired result.

A corollary of this is that within an object, you should prefer static stateless variables over member variables.

3. Localize the “side effects”

Ideally, side effects (e.g., printing to the console, logging, changing global state, file system operations, etc.) should be placed in separate modules rather than scattered throughout the code. Some "side effect" functions in functions often violate the single responsibility principle.

4. Prefer Immutable Objects

If an object's state is set only once in its constructor and never changed again, debugging becomes much easier because it will remain valid as long as it is constructed correctly. This is also one of the easiest ways to reduce complexity in a software project.

5. Use interfaces more often and classes less often

Functions that receive interfaces (or template parameters and concepts in C++) are more reusable than functions that operate on classes.

6. Apply good principles to modules

Look for opportunities to decompose software projects into smaller modules (such as libraries and applications) to promote reuse at the module level. For modules, some key principles that should be followed are:

• Minimize dependencies
• Each project should have a clear responsibility
• Don't Repeat Yourself
• You should strive to keep your projects small and well-defined.

7. Avoid inheritance

In object-oriented programming, inheritance -- especially when combined with virtual functions -- is often a dead end when it comes to reusability. I've had very little success using or writing libraries that overload classes.

8. Make testing part of design and development

I'm not a big believer in test-driven development, but writing tests first when you start coding makes it very natural for the code to follow many of the guidelines. This also helps to find errors early. However, be careful to avoid writing useless tests, and good coding practices mean that higher-level tests (such as integration tests or feature tests in unit tests) are more effective in revealing defects.

9. Use standard libraries instead of hand-written ones

I often see better versions of std::vector or std::string, but it's almost always a waste of time and effort. The obvious fact is - you're introducing bugs in a new place, and other developers are less likely to reuse your code because it's not widely understood, supported, and tested.

10. Avoid writing new code

This is the most important lesson every programmer should follow: The best code is the code that hasn't been written yet. The more code you write, the more problems you will encounter, and the harder it will be to find and fix bugs.

Before writing a line of code, ask yourself, is there a tool, function, or library that already implements what you need? Do you really need to implement this functionality yourself instead of calling an existing function?

Final words

I've found that programming is a skill very similar to learning an art or sport, you get better with deliberate practice and by learning from the experience of others. Continuously improving the quality of the code you produce helps you become a better programmer.