Is high-quality software worth it?
When we discuss high-quality software, there are usually two key factors people inevitably bring up to argue against it:
It costs more to build. The processes, procedures, and infrastructure needed to produce high-quality software are time-consuming. And time is money.
Because it takes more time, we can’t release features fast enough to satisfy our customers (whether they are internal or external) and keep up with our competitors.
If you take these arguments at face value, then it’s hard to see any real benefit from engaging in high-quality software development practices. If it’s going to cost more money AND we’re going to lose customers and market share, why bother?
However, when you delve deeper into these points and really analyze the effects of “quick-and-dirty” software development over time, you’ll see that they just don’t hold up. Sure, you might be able to get a few features out really quickly to satisfy some customers and maybe even gain some market share. But the defects and technical debt that build over time can be crushing and actually cost you more, lead to lower user adoption, and take you longer to deliver new features.
Let’s look at some key quality practices you can implement and how they can make quality software development worth it for your business.
Increase Test Coverage
The sooner you can identify and fix a bug, the cheaper it is to fix it. A developer catching their own defect in a unit test can fix it immediately. But a defect found by a customer in production code takes much more time to resolve - not only is customer support is involved, you now have a developer trying to fix code they haven’t looked at for months (if it’s even the same developer) that then has to be reimplemented into the main code branch, retested by QA, and redeployed. The overhead costs quickly add up, not to mention the business costs of an unhappy customer.
Obviously, the more test coverage you have, the more defects you’ll identify and fix prior to deployment. Coverage of 100% can be difficult to achieve simply through functional tests, but low-level unit tests allow you to test each and every function is entered into the system, in isolation of other functions.
While 100% test coverage still doesn’t guarantee defect-free software, working towards that goal will ensure you catch as many defects as possible as early as possible, thus greatly reducing your costs and improving your quality at the same time.
Automate Testing
Of course, testing, and increasing your level of test coverage, takes time. However, by automating your testing, or at least a significant portion of it, you can not only increase the rate at which defects are found, but can also reduce the overall time it takes to test.
In Test-Driven Development, for example, automated unit tests are written prior to the code even being written. Once the developer completes the code, the automated test is run. If the test fails, the developer updates the code and reruns the test. Once the code passes, it’s merged into the main code branch where it’s automatically tested against all of the other code for conflicts and issues. Again, when failures occur they immediately go back to the developer to resolve.
Not only is automated testing fast, but it removes human error and bias, making it more effective.
While there is an upfront cost to developing automated tests, if written correctly they can be reused and built upon for future releases. It’s best to keep tests small and atomic so that you’re not trying to maintain large test scripts. This also allows you to implement change-based testing and/or parallel testing, both of which will also increase the speed of your testing activities.
Refactor Code Continuously
Over time, as you add new features and fix bugs, your original code can become overly complex, difficult to read, and hard to maintain, especially if you have multiple developers working on that code. Refactoring your code is the process of updating and improving your existing code to reduce that complexity and increase the effectiveness of the code, while also making it easier to maintain. But you still maintain the original intent and function of the code.
If you want to increase the speed with which you can develop and release features, then you should be refactoring your code on a regular basis. This is where you can really leverage quality development over your less quality-minded counterparts.
This is because as code gets more complex it gets harder for a developer to go in and update - it’s difficult to read and may not be in a state that can be easily built out. And while it might have made sense to the developer that left your company 6 months ago, it’s a mystery to your new hire. So to compensate for any deficiencies and make the new feature work, more complexity is added and an even bigger mess results.
This technical debt builds over time and can severely impede the speed with which you can make updates and add new features.
Continuous refactoring, however, cleans up that messy, complex code, making it easy for future developers to quickly understand, maintain, and build-out.
Focus on Incremental Changes
While it’s tempting to try and implement big, complex features to satisfy a client or your sales team, it’s more conducive to quality and cost control to keep those changes smaller with more frequent, incremental updates.
First, this will allow you to incorporate more user feedback into your design, making for a better feature and user experience. While software quality is often thought of in terms of a number of defects, the quality of the user experience cannot be discounted from the equation.
Second, when you implement a lot of large changes at the same time, you increase the chance of conflicts and issues. Smaller, frequent updates make it easier for your teams to test, identify, and resolve those issues.
Conclusion
Foregoing software development quality practices can seem enticing: more features delivered quickly makes for happy customers. They’re happy, that is, until the bugs start popping up, useability goes down, and new features take longer and longer to implement. As time goes on, the true cost of poor quality becomes more and more evident.
But by implementing the proven quality practices we’ve discussed here, you’ll be able to not only improve your overall product quality, but also reduce development and maintenance costs, improve your user experience, and actually deliver features faster in the long run.