AI, Machine Learning and the Future of Software Development

Every successful interaction between you and your favorite app results from the combined efforts of a quality assurance (QA) team. These tireless problem-hunters ensure that every aspect of the apps that mobile device users worldwide depend on for their everyday needs works 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, we have to thank these often unsung heroes.

And when that team's efforts 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 are — that is, almost all of us nowadays — nothing short of perfection, and a QA team's primary goal is 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 more complicated. Today's software development world is becoming 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 appropriately performed.

It was a simpler time, with devices capable of much less and active in far fewer scenarios, so manual coding was a sufficient way of testing. While tedious work 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. They no longer needed to sniff out bugs in spaghetti piles of code manually.

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. It may be better to think of automated testing less as a revolutionary innovation and more as 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 various 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. As a result, we'll undoubtedly see more and more no-code solutions for various 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). In addition, 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. In addition, this technology allows QA teams to execute many tests across various devices and variant form factors.

And not in days, but in hours. Now that's a revolution.

No code still requires people; 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 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 increased 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. As we've discussed, this can be difficult to predict, and a complex app means complex testing scenarios and patterns. Nevertheless, the machine must understand and operate from this vantage point.
• Learning from real usage product data: A machine must understand how an app is used in different production environments. This includes understanding what devices may be in use, what language the device is set to, and 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), machine learning requires training data that assist in outlining software patterns.

These three items must be internalized and thoroughly tested for every code change. Then, they must be aggregated and prioritized in a seamless and intelligent manner. This is no small feat, but we 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 it's just a matter of time before the generation of entire websites based on a few user-specified parameters becomes 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.