The Software Development industry varies significantly from company to company and developer to developer and there are some common trends among developers that I have noticed in my career. In this article I want to address a common problem that I see among software developers: working too fast. All too often I see talented developers working at rapid pace because it pleases the company they work for when things are done very quickly but what the developer is failing to do the majority of the time is pay attention to what they are changing. While a rapid pace does quell concerns with management what it does that management does not see is cause long term issues with the codebase.
High quality code, as I spoke about in my Clean Coding article, is consistent and well formatted code that's easy to read and understand. It's difficult to make writing high quality code a habit and more often than not writing high quality code that's clean and readable takes more time than writing low quality code. The importance of writing high quality code is not only for new projects it's even more important in existing projects when you're doing things like adding new features or implementing bug fixes. Being able to understand the entire scope of your changes is vital for existing projects because if you're not paying attention to your changes you will break things that may not even show up until later.
Often I find that because many companies operate non-technical management staff they don't understand the issues that arise from low quality code, they only care about turn around time, this only serves to harm future development by causing fragmentation of the codebase that makes it far more difficult for people to contribute. You can of course fix this with refactoring but that's just more time added that could have been saved by allowing your development team the time to create high quality solutions instead.
Low quality code often leads to serious problems with a code base, these problems get exponentially worse as the size of the project increases over time as the low quality code sits in the code base and begins being used by more and more things without a good refactor:
- Security issues (oops did I miss requiring authentication?)
- Performance issues
- More & even worse bugs 🐛
- Exponentially longer development time for everything
- The need for large and time consuming refactoring tasks
You can think of this as a scale, on one side you have slow but high quality code and on the other you have quick but low quality code. There is a middle ground of course and that's an okay place to be but I would argue that it's always better to write as high quality code as possible. Over time you will become much more efficient and you will be able to write high quality code at an acceptable pace so that your company doesn't complain about the time it takes for things to get done up front if you work in that kind of enviornment. Of course if you do work in that kind of enviornment there are bigger problems, but that's an article for another time.
How do you manage code quality vs time? Do you believe that high quality code is important? Does your company value high quality code? Let me know your thoughts and opinions about this I would love to hear!