App stability is the measure of the quality of a mobile application. Stability is very much dependent on the device the user uses. Unlike web developers, mobile developers have no control over the environment where the app runs and have limited data about any events that happen within the user device. The remote user device which is completely away from the developers access can have device-dependent conditions, which in most cases might not have been the one that arises during beta testing. Most of the applications are released with bugs that go undetected during beta testing.

“Undetected bugs” might have already caused enough damage to your user base by the time some loyal user reports them. There are 2 ways out.

1. The first one is to engineer the application having in mind the traits of a stable application which is what all of us are trying to do and are mostly failing at.

2. The second is to reduce the damage caused by these undetected bugs with practices that identify them early on and release the fix before more users encounter them.

All those practices are necessary to attain a quality state where the app holds all the traits of a stable application. So yeah, what are those traits?

Lets now go through the each of the listed traits and the identified practices to attain these traits.

1. Optimized memory usage

Memory leakage is the primary issue which keeps an app away from attaining quality. Mishandling of the objects is the fundamental reason for apps to consume excess memory ultimately leading to an app crash. Abnormal memory usage can make the app experience sluggish.

Profiling memory usage is the right approach to figure out the leakages by identifying flaws in memory released by the objects. Coding practices and architecture that promotes reuse of objects can result in efficient memory usage behavior.

2. Successful API responses

Successful API calls are the bare minimum quality requirement for an app that works online. Though the type of internet connection that the user device functions is not under our control, we can take preventive measures in coding practices to avoid scenarios like the thread involving the API call being obstructed or mishandling of situation involving packet drops, etc.

Proper analysis of the network request or response data to figure out the causes of a network call/response failure is the ideal method. Handling the frequently occurring scenarios by fixing the root cause early on is the best approach to speed up release cycles. API level issues, wrong status codes, delay in getting a response to API calls, premature cancellation of requests, and error responses are failures to watch for. With data like request header and body, etc developers can drill down the cause of failure with ease.

3. Reduce crashes

Mobile operating systems are designed such that the inefficiency of an application creates no impact on the smooth operation of the device. When the resource utilization of an app reaches its allowed threshold , the OS kills the app. Crashes are often caused due to abnormal memory usages or due to wrong object references. Understanding the memory usage patterns gives the developer an idea about possibilities of optimization.

4. Seamless feature execution

User experience is not merely reducing the amount of work a user has to do to achieve their desired outcome. The amount of time the app takes to execute a feature is key to the overall user experience. Let’s consider ‘Check Out’ feature in an e-commerce app, the least user interaction and the faster process execution determines the quality of user experience.There is always a desired time with which the developer expects for a feature to complete execution and there always exists a fixed number of functions that are being called during a feature execution The common issues that can occur during a function execution are either

• Failure to return the expected value

• Or, delay in the function execution

And, there are always few fixed sequences with which functions are called and there always exists the desired time delay between each function call.

The more the clarity and data a developer has about the function call and duration of execution, the better he can optimize the performance, in turn, optimizing the user experience.

The Data hurdle

Without enough data, we rely on assumptions based on our previous experiences. The inaccuracy of the fix that we derive from these assumptions might trigger more issues. This happens primarily due to the uncertainty about the root cause.

The major pain point is that developers do not have a mechanism to get enough data from an app in production to do the root cause analysis and reproduce the bugs. Without a detailed bug report, developers stay helpless at reproducing bug scenarios in a short time and also fails at finding the fix.

In February 2017, Snapchat, after a not so successful IPO, had a pretty bad time under the pressure of the investment to scale the technology. Until that point, the Snapchat Android app was buggy: it only added six million new users during that quarter, a third of what had been added during the previous three months, with various complaints coming from users about the number of bugs they had to deal with every time there was an update. "If we are unable to improve the operability of our products on smartphones with Android operating systems, and those smartphones become more popular and fewer people use smartphones with iOS operating systems, our business could be seriously harmed.", the company said in its S-1 filing. This can happen to any company, such a situation can be avoided only at the cost of time and resources. An efficient approach to handle this situation is to vest up with technology and tools to cut down the time and resources.

It’s not always possible to code apps with 100% perfection, But it's always possible to fix the bugs early on if you have enough data to identify and reproduce them.

Fixing bugs in a production app requires a mechanism to fetch detailed bug reports within the app and must work seamlessly without any performance impact. Our engineers at Finotes have invested a huge amount of time building and optimizing the tool that reports bugs from mobile apps in production, with near-zero impact on app performance and very low storage space impact.