Why Are Apps So Bug-Ridden These Days?
Great developers, brilliant dev tools and even AI help product teams to build – worse apps than ever.
The majority of developers said in a recent survey that they spend a quarter of their time tackling bugs. Around 25% of developers go even further, saying half their time is spent on bugs. It’s a good time for businesses to be worried, because this is an upward trend: the time developers spend on fixing bugs is ever increasing.
But why? Today’s developers are more experienced, have access to better tools, editors with code and syntax suggestions, and are even able to learn from others’ mistakes publicly discussed on forums. Shouldn’t we be seeing fewer bugs and not more?
Software is becoming more complex
Over 20 years ago, you only needed one person to do everything; the design, the code, even setting up servers. Today, even a simple app will require a team effort, with all their communication challenges and communication overhead.
Designers will design the app, frontend developers build one half, and backend engineers the other. Each has their own strengths and blind spots, and the development of any new feature requires again, the whole team working in parallel.
As these various groups change their parts to make changes, their updates and additions won’t come back together perfectly. New changes across teams means many lines of preexisting code that’s built on assumptions.
Developers are only humans
Code is always easier to write than it is to read. When developers are introduced to new code, making sense of previous work can be extremely time consuming. Documentation of code is certainly helpful and could save a lot of time and money -- but writing documentation is often the last thing developers work on, and so the first thing that gets slashed when time is of the essence.
And while developers are becoming better and more experienced, there’s a huge need for them. There will always be newcomers, and people with 3-to-6 months hands-on experience will make mistakes -- they have to: that’s the only way to get better at anything.
Businesses are moving faster
Software teams have to release more often than ever to keep up with their competition and what their users need. In these fast-paced environments, some companies prepare a production release daily or weekly - they simply have no time to test every single feature before it hits the users. So internal testing gets overlooked, and it will be the users that are going to end up finding bugs first.
To make matters worse, today we not only need to test every feature, we also need to test every feature on every compatible device. Even when the devices are from the same family, the screen resolution, CPU, operating system, and hardware could all be different. No matter how good a QA team is, they can never guarantee that an application will work on every device just because it was tested on one.
Users with eagle eyes
There’s a generation that grew up with smartphones and web apps, and they have a low tolerance for bugs. They’re not willing to let small issues slide, even if those issues don’t impact their experience. They expect more, and they will be ready to jump ship as soon as there’s a better alternative.
In fact, 62% of bugs are reported by users through the app, and 25% are reported by users through social media. A real reason developers face more bugs today is simply because more of them are found - and reported.
Learn and grow
In industries where bugs can prove to be critical, they are also few and far between - but it comes at a price: it takes a decade to launch a new passenger aircraft, and startups rarely have the luxury.
Therefore, startups will move as fast as they can, and their software teams will be dealing with more bugs than ever before. But while tackling issues can be frustrating for developers, this isn’t something product teams need to worry about.
Bugs aren’t something we can eradicate entirely. Even the best developers can uncover issues in their code. What we can do is turn them from issues into opportunities. When you run into a bug next time, ask yourself: could we have prevented it? And could we have found it quicker