This is one of the biggest questions in programming. Everybody has an subjective answer to the question, as everybody develops their own style of programming over time.
For me good code has to fulfill these 5 criteria:
Now lets take a closer look at every criteria and what it means for your programming project
Code should have one key feature: It should work. Not functioning code is useless code.
Code has a very specific task it should do and it only should do that task. It should not do anything in addition that you do not expect.
Correct code also implies that it was built to specification . If you have a specification, you also can ensure that your code is correct by writing tests that verify that the code is doing exactly that what was specified.
If you have the choice between a complex expression and a simple expression that solves the same problem. then use the simple expression.
The complex expression is always a big door for unintended bugs. Additionally it makes it much harder to explain what is going on with your code.
Efficiency, strongly depends on the values / non-functional requirements of your project.
It means if you can avoid costly operations, duplicate operations or unneeded operations. then you should optimize your code to avoid these kind of structures.
If possible you also should optimize for performance, however for most algorithms you need to decide a trade-off if your code will use a lot of memory or a lot of CPU. Before optimizing you always have to define for what you are optimizing.
Code is written for humans. Another human should be able to read your code.
If you use complex structures it just makes it harder for someone else to figure out what is going on in your project.
The compiler does not care if the variable is called “f” or “isActive” in both cases the compiler produces the same bitcode. Naming things is very important.
And never forget in most cases you are going to be the one that will revisit the piece of code and you will not know anymore what “f” is, but will immediately understand what “isActive” means.
Code is never done. There are a lot of things that causes that code needs to be adjusted in the future:
- Additional Requirements
- New Features
- Dependency Upgrades
Now you can say, screw the maintainer of the project, you are only concerned about today. — However in most cases the guy that needs to fix something is the guy that created the code in the first place. — So do yourself a favor and write maintainable code.
What does it mean to write maintainable code? Have documentation, encapsulate functionality in a way
In the end good code is whatever you want it to be. If you are working with embedded systems and you want to create the most efficient algorithm, you will probably have other values as when you are working on a Web-Project.
You can define whichever values you want. The important thing is that these values must be clearly communicated to your team. Ideally by you leading as an example the others can follow.
In the end the goal of good code is that your project should deliver on time, suffer from less bugs, new team members can be easily onboarded, the team writes better tests and overall better communication (the specifications have to be more precise) etc.