19. 10. 2018
I am sure you are familiar with the following situation, too. You have updated a new version of an app and … damn! – your favourite feature is suddenly not working. However, software does not have to stop working only because of an update. Sometimes it just happens.
I will try to get you more insight into such failures and how we try to prevent them without too many technicalities.
Software parts cannot get worn out. If your software broke down, it’s never an inside job! There has to be an external influence.
Update of an Operating System or a Software
Developers of operating systems strive for an update compatible with the legacy apps. However, sometimes it does not come out with flying colours because even operating systems are still “human-made”. There are cracks in every new version. Although you can be ready for new update issues popping up, you cannot prevent them.
We, app developers, rely on a system to deliver its service. There is no easy way to guard against its sudden failure. Just imagine yourself preparing day to day for a possibility that no water comes out of the tap. It is possible it happens, but you neither just sit near the tap and check it every minute nor try to find a solution to a possible water outage. And I sincerely doubt you have gallons of water prepared “just in case”.
There is no other way but to try how the software update works with your application. Therefore, we test whether the issued update didn’t break your app.
Problems with Data
You can also spoil the app if undesirable/incompatible data are imported in. Every app developer tries to treat the inputs so the crack such data flows in is the tiniest. Third parties can often add to your pain in the neck.
How do we test data when we can’t predict the creativity of third parties? We import absurd inputs and check whether the app rejects them correctly. The app responds not only with “Error XYZ” that will prevent it from crashing, but also explains to the user how to input the data correctly.
Mistake(s) By a Developer
Unfortunately, software errors are an integral part of a software life. Each and every software has its flaws. Even nuclear power plants, weapons, and satellites have their special protection systems since software cannot be proven to be 100% error-free.
The only way to prove it bug-free is to prove the programme correct by a mathematical proof. Let’s be honest, most programmes are too complicated and vast to have a mathematical proof traced back to the statement.
Working on new features can also inflict some difficulties in the app functionality. Then how come developers still dig into the systems when they were working just fine?
A modern software is like a set of boxes that communicate between each other. Imagine you are developing a simple calculator. It adds, subtracts, divides and multiplies. Next step – brackets. From a user’s point of view, let’s just add left and right brackets and the job is done.
But the developer has to adjust many boxes: the box that renders math formulas onto the display, the box that computes, the box of calculator’s keyboard and the box checking the validity of the inputs e.g. the input „1(+)2“ would be rejected.
As you can see, although all the boxes have already existed and worked, now we have to adjust their operations. It is then terrifyingly easy to break the operation of “adding”. An error can easily occur in such a simple machine, not even speaking of hundreds of such boxes and their interaction.
The best remedy against bugs is automated testing. Imagine them as guards watching whether the calculator‘s “boxes” will get to the right result with 1+1, -2+3 and also with -(-2+3) etc.
Every time we release a new app version, we launch automated testing again just to confirm nothing broke down. Unfortunately, the stumbling block is that the range of all possible errors cannot be covered even with automated testing. Some bugs can still slip in. Moreover, automated testing is pretty time-consuming because someone has to write the tests.
Despite such disadvantages, automated testing is currently the best remedy developers have against bugs. It should be followed by manual testing and beta testing.