How to balance developer productivity and code quality? These are two of the most pressing concerns for any software development organization. Producing quality code has always been a challenge for developers, which has led to clean code standards, development methodologies, and other attempts to make the process easier. What you need is a practice of improving code quality without sacrificing development velocity.
Here are five valuable insights from industry experts to help you balance developer productivity and improve code quality.
Insight 1: Do not write code unless you have to
As a thought exercise, imagine that every line of code costs you $1,000. Would you change what lines you write?
Rahul Subramaniam, CEO, DevFactory
The truth is that even the best line of code written today can still accrue technical debt over the next few years. Due to the fast-changing technology landscape, high-quality code in today’s context may be viewed differently years from now. Therefore, only write software that differentiates your business or provides key value-added capabilities.
Rahul, CEO of Devfactory noted that it is common for 80% of a product codebase to be focused on infrastructure or support functions. And as it happens, much of that functionality can now be handled by cloud providers such as AWS. Let’s take Fogbugz, an issue tracking system, as an example. It comprised 1.7 million lines of code when it was written 20 years ago. However, when the product was recently rewritten on top of AWS, it had only 5,000 lines. The bottom line – a smaller codebase makes it much easier to maintain higher levels of quality.
The concept of Domain-Driven Design is something you need to consider and make it a part of your methodology. Consider the core subdomains of your business, and focus on components within those areas. Consider off-the-shelf or managed service solutions for other concerns, as they don’t yield the same competitive advantage for your business as others.
Insight 2: If you build it, you support it
When it comes to the build or buy decision, it is increasingly more important what we choose to have our developers spend their time on.
– Ivo Yeuh, Director of Software Development, Envision HealthCare
The concept of ownership is a prominent part of the DevOps philosophy. It motivates engineers to write higher quality codes because they (or their teammates) are responsible for it. If something breaks, they will be the ones who are called to fix it.
The functional behavior of software usually determines when the development is “completed”. However, the structure and quality of the code should be given equal importance throughout the product’s lifecycle.
Finally, engineers should work towards common architectural goals to deliver the flexibility required to meet the dire needs of the business on an ongoing basis.
Insight 3: Address quality problems at the core
We need to constantly coach developers, similar to how an athletic coach reviews exactly what happened using game film. Do this with each individual developer, and within 6-8 weeks you can start eliminating (code quality) issues.
Rahul Subramaniam, CEO, DevFactory
Apart from team reviewing sessions, take a proactive approach by sitting down with each developer at least once a week. Preventing problems at the outset is more sensible and cost-effective than dealing with them throughout the product life cycle. Isn’t it?
Bear in mind that code quality does not just start with the QA process. Instead, it needs to be addressed at the source by coaching developers how to write better code from scratch.
Code quality tools do help, but be aware that many of them output false positives. However, there are some powerful coaching tools like DevGraph’s DevCoach, which significantly help improve developer productivity and code quality.
Insight 4: Technical Debts includes interest payments
Don’t write checks that your team can’t cash.
James Rutt, CIO, The Dana Foundation
Taking shortcuts to meet your deadline can result in adding technical debts, and the total cost is increased further by the “interest payments” required to undo that shortcut. Once that quick deadline work is complete, you can then introduce the long-term solution.
Technical debt can occur for various reasons other than opting for shortcuts, like occurring simply over time or due to changes in context. It would help if you made intelligent decisions on whether to invest to ‘get it right or take shortcuts for immediate results.
Insight 5: Use Hackathon to bring down technical debt
We set aside time not only for break-fix and non-sprint related work, but also for hackathons per team (to address technical debt).
Warren Lenard, CIO, Byrider
Hackathons are a prime indicator of where we are headed. Developers must quickly stitch together components that are readily available to them.
Rahul Subramaniam, CEO, DevFactory
Hackathons provide concentrated time to focus on cleaning up the code and offering rewards and recognition. It can help developers strengthen their knack to stitch together components readily available to them quickly.
Warren Lenard, CIO of Byrider, suggests that you allocate at least half a day for planning before spending a whole day for the Hackathon event itself.
3 steps for improving code quality and productivity
Software quality should be top of mind for most organizations. Here are our three best tips for improving code quality before issues become unmanageable. Improving code quality naturally leads to an increase in development velocity.
The first step in improving the quality of code is finding out where things went wrong. Most software teams utilize automated test suites and static analysis tools to detect issues. The problem with this approach is that they generate too many false positives. If developers and managers detect inaccurate assumptions about code quality, it will undermine any improvement efforts. Therefore, you need a process for analyzing code that generates actionable insights about significant problems within the source code that are too difficult to ignore.
Refactor Decaying Code
Once issues are discovered, they must be dealt with immediately. Putting off errors can lead to technical debt and a drop in development velocity. Problems occur when developers recognize existing issues but fail to correct them when they commit new code. This perpetuates a cycle in which code continues to deteriorate, and it becomes unclear from where the defects originated.
That’s why it’s critical to change developer behavior to encourage each code commitment to include not just new functionality, but an improvement to the quality of code.
Without any intervention in developer behavior, they’ll likely continue to make the same mistakes. Targeting low performers with regular coaching can decrease the flow of defects and dramatically improve code quality over time. And while coaching may not be a priority for developers, they can see massive productivity increases that ease their pressure to meet deadlines as well.
Experts say that code quality and productivity do not always have to be mutually exclusive. By focusing on quality from the start (through right coaching and tooling) productivity gains can be achieved through fewer defects and less time spent on rework. Deadlines are inevitable, but consider the total cost of ownership carefully before making tradeoff decisions as technical debt tends to accrue interest. It is essential to deploy a solid framework to build your products consistently to help move your organization towards its architectural goals.