7 bad programming practices every programmer needs to be aware of in order to avoid them
1. Speed kills.
Write your code carefully, debug it, integrate it, refactor, optimize and repeat. The challenge is quality, not quantity. Software engineering requires skilled craftsmanship. There is too much crappy code being written daily in the world.
2. The lack of self-criticism.
Being satisfied and contented with one’s code is a dangerous habit. Take a major piece of code you wrote a few years back and if you cannot see how to improve it, you are not progressing forward technically. Be willing to learn from others. Learn to recognize, acknowledge and learn from your mistakes.
Getting code to work is the lowest acceptable outcome. One should always strive for clarity, simplicity, extensibility, modularity, predictable runtime behavior and scalability. Code that has these highly desirable attributes is more stable, testable and maintainable. If you’re any good, some future engineer will have the task of reusing your code. Make sure this engineer has kind thoughts for you.
4. Using the first proposed design.
There are many possible designs for software modules. Solve the task at hand N different ways conceptually on the whiteboard. Then critique each design in terms of pros and cons. Then choose the optimal design with the best trade offs. If you can only come up with one design you are not thinking hard enough. Implement the chosen design. Do not be lazy.
5. Cut & pasting code.
This is a dangerous habit. Crappy code propagates with slight modifications like a horrible virus with deadly mutations. When the code has to be forklifted to retrofit the latest API some poor sap has to fruitlessly track down N random obscure hidden inline locations as opposed to one clean API interface (use an interface, function or class please). IDE code refactoring tools should be used instead. Less is more. Create less code by refactoring, not more code. Adding more code by cut & pasting code is very evil creating an unmaintainable codebase.
6. Lack of attention to detail.
Although coding requires high-level design and conceptualization, skills, it also requires extreme attention to detail as it is unforgiving. Code that is 99% correct is as nonfunctional as code that is 50% functional. Code either works or it does not, approximate incomplete solutions have no value.
7. Lack of ownership.
Coding is a refined craft which requires pride of ownership. If one is the original author of a software module, one should always being willing to improve it, maintain it and support it indefinitely. Disowning code breaks the positive feedback loop for improving your skills using the complete software lifecycle. Your code should have an infinite lifetime warranty honored by your sincere personal commitment. Great code does not have an expiration or a use by date.