People have a habit of overcomplicating things-and when it comes to your developers and software, this can be a huge problem. Financial strains, or pressure from managers or investors, can make you develop bad practices or messy code, resulting in overcomplicated software.
When left unchecked, an enormous technical debt builds up and your team becomes increasingly frustrated. By not implementing good practices early on, you risk laying a weak foundation for both your team and your product that will ultimately negatively affect your company.
Below, we identify the impact overcomplicating software has on both your technology and your team, and outline the best ways to create a positive working environment that produces great results.
The technical side: the debt
Imagine the scene: you're working hard on a new piece of code, and your manager comes and asks if you can hurry up. You have a choice: to build the right thing, to build the thing right, or to build it fast. What do you do?
Every day your team has to make a trade-off between these three choices in order to move forward and meet deadlines. The technical debt you build up is the balance of all the decisions you've made, and those you haven't.
While making the easiest choice in the moment is understandable, the decisions you make in the moment directly impact the choices you are able to make later on. For example, if you lay a foundation of poor quality software, it will reduce your ability to build quickly in the future. In the end, it comes down to a trade-off between short-term convenience and the long-term outcome.
What causes technical debt?
The main causes of technical debt are:
A lack of time
In fast-paced working environments, time is always an issue. Being under pressure means you can spend less valuable time refactoring, writing tests, or considering and implementing proper architecture and design.
Whether it's relying too much on your IDE, prematurely optimising code, or not properly formatting code, bad practices are easy to develop. You may gain some short-term benefits from certain bad practices-but in the long run it leads to serious issues.
We get it. Sometimes it's not feasible to completely overhaul your systems and infrastructure. But not staying up-to-date opens you up to a number of vulnerabilities that impact you later on, including increased security risks and low-quality code.
Why is technical debt so serious?
At first glance, a technical debt can just sound like a time debt. You and your team have made decisions and compromises, and all that's needed to do is to go back and fill in the gaps. But the ripple effect of a technical debt extends way beyond time management issues.
The main causes of bugs are no secret: lack of communication, ambiguity with regard to requirements, programming errors, reworking finished products, and stress. Every one of these is either caused by or exacerbated by accumulating technical debt.
The knock-on effect is, of course, reduced speed. If you have to spend valuable time sorting out messy, spaghetti code, it takes longer to deploy to production and the whole project suffers.
Reduced flexibility & responsiveness to customer requests
Agile and DevOps practices are good ways to reach objectives, but they require flexibility. Evolving the software means implementing updates and customer requests on a rolling basis. But if you keep getting held up at the review stage, it's impossible to meet short-term deadlines.
The human side: combating lack of motivation, boredom and frustration
Once your team begins to lose focus, bad practises creep in, which results in overcomplicated software. This then leads to a downward spiral in morale, as the scale of technical debt blurs the product vision that originally excited and unified the team.
The fact is, people want to feel they are part of something meaningful and that their work is valuable and useful. Without a clear understanding of the product as a whole-what it is, who it's for, and why it's being made-your team will be stuck solving one small issue at a time without understanding how their work fits into the bigger picture.
This negative effect can be further compounded by micro-management. When this happens, team members can start to feel like workers on a factory line, stuck repeating the same task ad infinitum. By not giving engineers autonomy and the freedom to explore other areas of the project, you hinder their creativity and ability to make a meaningful impact on the work at hand.
Software Craftsmanship: What is it, and why you should implement it.
You want to avoid the factory-line feeling: what do you do? Your team is made up of passionate, dedicated specialists-and they need to be treated as such. By implementing good practices, your developers become software craftsmen that design a high-quality product. In short, software craftsmanship encourages software developers to hold themselves, their team, and their code to a higher standard.
How to establish software craftsmanship?
Establishing software craftsmanship is a combination of creating well-crafted software, steadily adding value, building a community of professionals, and working with trusted partners.
Building well-crafted software
When building your software, don't aim for a product that works-aim for an artisan product. This means following the best practices that best suit your product and working dynamics. Below, we discuss some of the most popular approaches to coding and how they can benefit your workflow.
- Clean Code
Create high-quality code that's elegant and easy to read by running tests, avoiding duplication and ensuring you leave clear, legible notes for anyone who reviews it. This is essential for the smooth running of your product development. It is key to onboarding new developers, pivoting or adjusting your product, and helps with general maintenance.
- Code review
A second pair of eyes is essential. Code reviewing involves one or more people reviewing the quality of the code being written by other developers before they push it to the main branch. Whoever is reviewing the code cannot be the person who initially wrote it.
With Test Driven Development, you repeat a very short development cycle. It begins with the developer writing an automated test case that's initially failing. This test case defines a desired improvement or new function before producing code to pass the test. Lastly, the new code is refactored to the desired standard.
Based on design principles by Robert C. Martin, and arranged into a mnemonic acronym by Michael Feathers, these five principles are key to object-oriented programming (OOP). They are:
- Single-responsibility principle
- Open-closed principle
- Liskov substitution principle
- Interface segregation principle
- Dependency Inversion Principle
It may seem daunting at first. But with time and consistent adherence, it becomes a part of you. By following this, your code can easily be extended, modified, tested, and refactored without any problems.
- Pair programming
Pair programming is an Agile software development technique originating from Extreme Programming (XP) in which two programmers work together at one workstation. One person-the driver-writes the code while the other person-the navigator-gives instructions and reviews each line as it's written. While reviewing, the navigator is able to consider the strategic element of the work, and the driver can focus on the tactical aspect of the task at hand.
By sharing ideas and perspectives and frequently switching roles, the pair are able to collaborate and work together to resolve difficult tasks. This can significantly improve the design quality and the resulting code will have fewer defects.
Steadily adding value
With financial issues and strict deadlines, managers can end up overpromising and under-delivering. This reactive approach to coding always leads to increased stress and lower quality. By taking a step back and focusing on what matters, we are better able to steadily add value over time, rather than rushing to offer a solution that is not viable or sustainable.
Creating a community of professionals
Your team is more than a group of individuals. It's a veritable guild of craftspeople who are dedicated to producing the highest quality product. By establishing an open and collaborative culture, you encourage an environment of skill-exchange, where each member helps each other to resolve issues, improve, and create something they're truly proud of.
Learning to say "no"
As programmers, we always have to be professionals first and foremost, and this means learning to use your judgement as an expert. With your knowledge as a coder, you will often be in the best position to design and implement solutions in your company. Sometimes, your manager may come to you with a direction that makes no sense to you and could harm the project. In these situations, you have to be willing to put your foot down and say no. By standing on principle and setting firm lines, you can place yourself in the best position to negotiate and bring alternative, viable options to your team.
Gaining a trusted partner
Agile Partner was founded upon the concept of partnership. We work hand in hand with our clients to ensure we have a 360o understanding of their business and team before taking any further action. If you're ready to build well-crafted, sustainable and exciting software, set up a call with one of our Agile experts today to arrange a training session or workshop.