Every successful interaction that occurs between you and your favorite app is the result of the combined efforts of a quality assurance (QA) team. These tireless problem-hunters ensure that every aspect of the apps that mobile device users the world over depend on for their everyday needs work without a hitch, through every single release and update.
When you wake to the tones of your morning alarm clock, check the weather, or message a loved one, it’s these often unsung heroes we have to thank.
And when the efforts of that team fall short, they certainly hear about it: Many users do not hesitate to provide negative feedback on popular (and very visible) review sites.
The expectations of the modern mobile app user is — that is, almost all of us, nowadays — is nothing short of perfection, and it’s the primary goal of a QA team to ensure an error-free product on each deployment.
The presence of errors and issues can quickly sink an app. Unfortunately, there’s nothing easy about ensuring a bug-free experience. And it’s only getting harder. Today’s software development world becomes more complex by the day, and testing for the many potentials and scenarios that those complexities bring them means that testing itself has become more and more complicated and resource-intensive.
Given the history of mobile app development, it’s more than reasonable to expect that apps will only become more complex and require even more advanced and frequent testing. But must this be the case? Are we doomed to an ever-increasing need for more staff members and bigger and bigger QA teams?
The 1980s: Manual testing
Let’s take a few moments to consider how we got here. Up until comparatively recently — the “wow-I-guess-that-really-was-a-long-time-ago-now 1980s” — software QA teams relied heavily on manually testing their devices to ensure products pushed out to market performed properly.
It was a simpler time, with devices capable of much less and active in far fewer scenarios, and so manual coding was a sufficient way of testing. While it was tedious work that took a lot of time when thoroughly performed, manual testing worked well for testers.
But technology, being the constantly evolving and improving beast that it is, ushered in changes in the form of automation that vastly improved the testing process. Software advanced and grew more complex.
The 1990s – 2010s: Coded test automation
Over the next few decades, advances in testing freed QA testers from the requirements of hands-on laboring through test cases. No longer did they need to manually sniff out bugs in spaghetti piles of code.
They had a new weapon in the war on software issues: Large-scale manual testing had become impractical, and, if any QA team was going to thoroughly test a would-be release in a reasonable amount of time, they needed to execute test scripts through an automation tool.
So, had the war on complexity been won? Not quite. In fact, it may be better to think of automated testing less as a revolutionary innovation and more as yet another step in the arms race against the ever-advancing complexity of software.
The clock was ticking without a clear victory on the horizon. Automated testing lost ground as mobile apps exploded in popularity and became tools central to many of our day-to-day lives. Fortunately, around the corner was a long-expected change, a true revolution.
The 2020s: No-Code test automation
Up until very recently, the plight of the QA testing team had become quite dire indeed. To ensure a quality product release, automated testing required ever-increasingly complex code apparatuses meant that QA teams needed to dedicate more and more programmers specifically to testing, rather than to other tasks, like producing new features. Not only was this increasingly expensive, but it also meant pushing back release dates further and further into the future. But the alternative, a disastrous launch, could be far, far more expensive (as many high-profile broken releases attest).
But then came the inevitable. By way of the principle of abstraction — in which interface-based representations pave over incredibly complex processes (consider the ones and zeros hiding behind the article you’re reading now, for example) — many specialists had long heralded the arrival of a rise in a new layer of abstraction, a “No-Code Revolution,” and this has indeed come to fruition of the past few years.
A handful of platforms have recently appeared that allow for no-code solutions in a wide variety of industries. One of the more visible examples of the No-Code Revolution is the popularity of truly what-you-see-is-what-you-get website editors (think Squarespace or Wix), while in the far less visible area of software testing, Sofy, the company I founded, is a unique platform that provides no-code testing for mobile apps.
The no-code revolution has yielded a sea change, allowing non-specialists to handle complex tasks, and freeing up those specialists for other tasks. We’ll undoubtedly see more and more no-code solutions for a wide variety of industries in the near future.
2025? Truly intelligent self-testing software
That said, in the scheme of things, the No-Code Revolution is just another step forward, and I believe that the next step of software testing is software that tests itself.
I’m not alone on this: Like the No-Code Revolution, self-testing software has been a projected reality for years. At the rate of change and growth in technology, it’s not at all absurd to imagine that by 2025, intelligent test automation (that is, self-testing software), where testing AI operates without human intervention, will greatly expand.
Currently, limited implementation of intelligent testing adds speed and quality to software releases through reliance on machine learning (ML) and AI platforms. This allows for fast and continuous testing (and with it an increased ROI). AI can duplicate human intelligence while ML makes computer learning possible without human intervention.
Artificial intelligence and machine learning employ deep learning-based algorithms to access data and learn from that data through the extraction of patterns for more efficient debugging and decision-making. With this technology, QA teams can execute many tests across a wide variety of devices and variant form factors.
And not in days, but in hours. Now that’s a revolution.
Humans & machines
No-code still requires people and people aren’t machines: They make mistakes. Even with no code — though greatly reduced — human error remains a factor from which serious issues can still arise. Consider too the excess use of resources, time, and effort that arises from human testing.
Intelligent testing automatically generates and maintains test cases and yields valuable benefits, which can be summed as an increase in productivity and output quality. But for intelligent test automation to happen, the following ingredients must first be combined:
- Learning from human input: When a machine tests, it must act as a human. It must learn what a human needs and wants, and how a human behaves with a device. This can be difficult to predict, and — as we’ve discussed — a complex app means complex testing scenarios and patterns. The machine must understand and operate from this vantage point.
- Learning from real usage product data: It’s important that a machine understands how an app is used in different product environments. This includes understanding what devices may be in use and what language the device is set to, as well as its use flows, including utilization of menus, screens, and actions.
- Training data: Just as with autonomous vehicles (a nut that still hasn’t been cracked), a machine learning requires training data that assist in outlining software patterns.
For every code change, these three items must be internalized and thoroughly tested. They must be aggregated and prioritized in a seamless and intelligent manner. This is no small feat but, for example, we at Sofy continue to work toward this next step.
We’re not there yet. Each of these steps must be completed before we can move forward, but it’s really just a matter of time.
And self-testing software is just one step: I predict that we can expect other examples of no-code, just now hitting the market, to move toward machine learning. I believe that it’s just a matter of time, too, before the generation of entire websites based on a few user-specified parameters will become a reality. Today the No-Code Revolution has finally arrived, but with it has come the beginning of another revolution dawning just over the horizon.