“Quality is free, but only to those who are willing to pay heavily for it.” — DeMarco and Lister

Software Development Is Misunderstood by non technical people, Quality is fastest way to get code into production. The common approach on software projects is fast, low-quality development, creating complex code, problems and stressful failing project.

People question the cost of good developers. Their price is higher but the total cost of cheaper developers is more. Why the Cheap Option in Software Development Costs More?

There is a myth that create quality software takes longer because it involves extra steps compared to low quality development.

Bad developers believes the extra steps such as DevOps, unit testing, documentation and code reviews slow down development. They don’t understand the benefits of best practices and view anything other than writing code/creating software is a waste of time.

Customer/managers view non-code creating activities as time wasters. Those who don’t understand software development view best practices of software development with suspicion because they don’t understand the benefits. When non-experts tell experts what to do, it’s because the non-experts have oversimplified the decision.

Software isn’t a short-term activity, it’s a long-term activity that aims to create software that will be used for years. The fastest way to create software is to create quality.

What is quality development?

Quality development will have

• Standards
• Development processes
• DevOps/ALM
• Unit testing
• Code Reviews (enforces standards)
• Documentation
• and other best practices

There is a myth that quality development takes longer, but after the initial setup, quality development takes the same time as low quality development. Quality development has extra steps, but the process is understood and the development team knows what to do.

Bad development is in chaos, the code is harder to understand. Changing code is difficult because it's brittle and there are no unit tests. It creates more bugs, problems and issue and the manual steps will take longer to fix.

The illusion of bad development is faster is only initially for the first 2–3 months. The more code, complexity, developers and time you add to a project, the slower the project gets.

Bad development adds technical debt and complexity at a fast rate that anything other than a small project will soon generate a multitude of problems. Low-quality code does a poor job of managing complexity and technical debt.

Why would I do that?

I remember hiring a developer who I wasn’t sure about. His CV was fine, his interview was fine, but the developer wasn’t a strong yes. I learned never to hire someone who isn’t strong yes.

The developer didn’t see the reason for extra (unneeded in their mind) steps of quality development. They didn’t like DevOps, hated unit testing, tried to skip code reviews and challenged all the standards.

The developer used to speed through development, their code missed requirements and always had bugs. They never found incorrect requirements or missing requirements, and the documentation was poor.

The other team members were unhappy with the developer being in their team because the lack of quality was slowing down the entire team, the bugs were dragging us backwards.

When I talked to the developer, they were oblivious to these problems and complained about the slow speed of the other developers. The developer boasted about creating software at a faster rate than everyone else. When asked about the high number of bugs, the developer was adamant they didn’t create more bugs than other developers.

I got the facts which showed the developer was creating twice as many bugs as the rest of the developers. The developer questioned the figures and then questioned the effects.

In the end, the developer left because he was never happy with the development approach and culture of the team.

Chaos Development

When software development is bad, it can unscramble an egg

I have moved onto failing projects to help improve them. When you join a failing project, it's chaos and confusion.

This is development chaos and the surprising fact is everyone is working super hard. The development team works extra hours to work around their poor practices and low quality.

Software Development at the Edge of Chaos describes what happens when complexity goes uncontrolled, it create chaos in the code and on the project.

Can’t teach someone they already know

When building a development team, it's easier to train graduates than trying to get bad developers to learn an alternative approach. The issue is attitude and mindset. Graduates were keen to learn and improve because they understood they didn’t know how to be create quality software.

Bad developers believe they are already good developers and don’t acknowledge they have anything to learn. You cannot teach someone who believes they are an expert developer because they spend more time talking than listening. Bad developers don’t know what they don’t know, but more damaging is they don’t see a reason to learn.

Working with bad developers helped me realise why being humble and curious were traits of good developers. The technical environment is always changing and developers should be open to learning and improving their knowledge, skills, and practices.

You can’t teach someone who thinks they are an expert and aren’t willing to learn.

99 problems

Low quality development solutions create problems

Low-quality development leads to more problems. The problems make a bigger impact and are harder to fix. Manual processes, harder to understand code and lack of documentation, make fixing issues difficult.

Problems are magnified on bad development projects, the impact of those problems are bigger.

With the lack of documentation and processes, when someone leaves the knowledge leaves with them.

When software development is bad, it can unscramble an egg

Quality development

Quality development controls complexity with order, automation, rules, best practices, processes, and knowledge. Processes, best practices and automation enforces quality with minimal effort from senior developers.

When you work on a project with quality code, the development team can fix and deploy rapidly.

Quality development teams can restores an environment within hours, so if the worst happens they can recover quickly. Quality development manages the effects of change on the code, it minimises the disruption change causes with well designed and tested code/software.

Conclusion

Developers who disagree with best practices and quality steps are trying to make the facts support their development view. Writing code fast is trading speed for quality. This approach will cause problems and the problems will keep growing with the more software you create.

Complexity and technical debt will consume the project and create a death spiral of making developers leave. People who don’t understand software development won’t see these problems coming because they think projects are about creating software.

Writing code, creating software isn’t about the creation, it’s about the quality. Every line of code or customisation your create has to be supported, understood, maintained, extended.

Experienced software developers create code to be maintained not for creation. Inexperienced software developers create software as fast as possible and think about maintenance afterwards.

Code quality is the punch junior/bad developers don’t see coming, and it knocks them out cold. They end up with code that gets more complex and harder to work with, it vomits bugs and problems.