There's No Such Thing as a Bug-Free App
A 120-ton space shuttle is waiting to be launched. There’s no human sitting in the control center, waiting to push the button that would launch the space shuttle. Instead, it’s the software that gives order to four identical machines onboard the space shuttle that pulls information from thousands of sensors and make hundreds of millisecond decisions.
This software is bug-free, doesn’t crash and doesn’t need to be rebooted, as reported by FastCompany. It even goes onto calling the software perfect -- as perfect as human beings have achieved. The last three versions of the 420,000-line program had just one error each.
If the software has bugs, people die. Period. The software was maintained by a group of 260 women and men working day in and day out to ensure the software delivers what it’s supposed to and ensure that no one dies.
So coming to the question: Can a human being write bug-free applications? The technical answer is yes. The practical answer, on the other hand, is not so much. The reason behind this is that it’s just not economically viable, unless you’re building a life- or mission-critical application.
To understand why it’s unrealistic to expect bug-free applications or software development, let’s understand how the software behaves. A piece of software or an application does not run in isolation on a perfect device or system. It has dependencies of the platform that are out of its control and the existence of libraries makes it even more complex.
If you want your application to be bug free, then you need to also ensure that every library you utilize is also completely bug free -- which is simply possible when you’re relying on a third-party for this. Speaking of third-party, even the slightest of complexities in an application triggers the integration of a third-party application program interface-- again, an external reliance with no control.
In his latest book, Art of the Start 2.0, Guy Kawasaki writes, “Good enough is good enough. There is time for refinement later. It’s not how great you start -- it’s how great you end up.” It’s a good thought when you’re building your product company ground up. Ask any successful tech product entrepreneur, and they’ll tell you how buggy their mobile or web app was in the initial days.
Accounting for every single use case in the initial days of your product is tedious and can take your mind off other important things -- like product validation. Your best bet would be to factor in the typical use cases as imagined and ensure those are bug free.
Bugs are only bugs when they are reported. So here’s how you should approach your first or your next application development project.
1. Expecting your developers to write bug-free code should not be the goal. Rather, focus on giving your early adopters a functional product that can solve their problems.
2. Many bugs are raised simply due to a shortfall in what the software does and what the end user is expecting. This can easily be resolved by insisting on creating a detailed functional specifications (FS) document before a single line of code is written. Here’s a sample FS Document for reference.
The FastCompany article further reports that at the on-board shuttle group, about one-third of the process of writing software happens before anyone writes a line of code.
3. Most programmers across development firms don’t do unit testing and wouldn't even know how to do that, which means that as a company you would have to hire more expensive ones.
4. Considering all costs and decide for yourself what matters most-- inexpensive software that works well 99 percent of the time or an expensive one which works well 100 percent of the time. Also, you want to go live with this application now, not in ten or twenty years.