The past decade or so has been an exciting time for software developers. Project methodologies have moved away from rigid, staged structures. They are embracing more fluid, fast-paced agile models.

We now live in a hyperconnected world. The internet is penetrating emerging markets. Social media is exploding. IoT technology is getting increasingly sophisticated. This translates to an exponential rise in demand for software products and services. Which in turn means software needs to be delivered at breakneck speeds.

Software developers have benefited from this demand. They have adopted modern technologies powered by cloud computing and artificial intelligence to advance exponentially in recent years. Yet QA, particularly test automation, has advanced only linearly.

Advances in software development

Let’s look at some of the advances in software development that have deeply impacted the way companies keep up with the demands for new software.

Agile Development

The agile approach to software development was first introduced in 2001. It was an alternative to the traditional waterfall methodology.

Waterfall had its benefits. The need to document and sign off every step before moving to the next meant error-free code and pristine quality. But around the turn of the millennium, the need for larger scale and faster releases far outweighed the need for perfect code. Moreover, waterfall often led to software that was already outdated as soon as it was released. Thus, the emphasis shifted from quality to speed, and hence agility.  

“Iterative” and “prototyping” models, focused on incremental builds, evolved into the Agile approach. Agile embodied flexibility, responsiveness and teamwork. The Agile manifesto values the following:

• Individuals and interactions over processes and tools
• Working software over comprehensive documentation
• Customer collaboration over contract negotiation
• Responding to change over following a plan

Agile has become the de facto norm for software development projects. 20 years may sound like a long time. But it’s impressive that an entire global industry has switched course in such a significant manner. Agile adoption within software development teams has increased from 37% in 2020 to 86% in 2021. The agile approach has inspired models such as Scrum, continuous integration and continuous delivery (CI/CD), and DevOps. These models are now the mainstream of the development world. And agile models are even being adopted in non-IT functions, such as marketing, finance, HR and general management.

No-code/Low-code Development

The concept of no-code and low-code systems is not new. Even in the 90s, businesses sought a middle ground between expensive custom builds of information systems and cheaper ready-made solutions that did not meet all their needs. Soon we had platforms such as WordPress, Wix and Squarespace offering the masses a way to build entire websites without developers. Just a few years prior, this was being done by seasoned software engineers at the biggest companies.

Cloud computing has made it easier to break up the coding divide. We now have a burgeoning automation industry. Robotic process automation (RPA) is helping offload mundane administrative processes. SMEs are using RPA to focus on core activities. Intelligent process automation (IPA) combines AI and RPA to help enterprises learn from their processes. They can scale or optimize their operations more easily. Drag-and-drop and plug-and-play have opened up software configuration, management and optimization to a previously untapped population of “citizen developers”. Business-centered, non-technical resources can help digitize and scale operations faster than ever before. The possibilities are, at least theoretically, limitless. 

‍

Software developers can offload some of their increasing workload to automation. This means they can use their sophisticated technical skills for more advanced programming. And this helps cut the time to market for new products and services.

How has QA advanced?

In 2004, Selenium was seen as the next step in software testing. As an open-source testing solution, it certainly was an inflection point for quality assurance. It opened up the self-contained testing phase of software development to a global community of coders and testers. It stimulated innovation in QA. It helped create the shift from manual to automated testing. This shift was roughly aligned with the shift in development models to agile approaches. Software was being developed faster, tested faster and delivered faster.  

Selenium became the go-to test automation framework for QA. It has remained so to this day. Yet, when we break down the evolution of Selenium over the last two decades, the pace of innovation does not quite measure up.

Growth of Selenium

Let’s look at how Selenium has advanced over the years:

• 2004: Selenium Core is released as an open-source testing tool for automating repetitive tasks in web applications. Selenium Core could only run with web applications hosted on the same domain. This was because of the predominant “same origin policy” security protocol.
• The security issue is mitigated by releasing Selenium Remote Control (RC). Selenium RC used proxy servers to connect to web applications on different domains.
• In 2006, Selenium IDE was released with a Firefox extension (and eventually a Chrome extension). The IDE can record and playback UI actions as inputs to the testing tool. (Though it was released in 2006, it started being properly maintained from 2018.)
• In the late 2000s, web applications proliferated. Testing needed to be done on a larger scale. Selenium Grid allowed tests to be distributed and executed in parallel across multiple machines.  
• The next step was a cross-platform testing framework known as Selenium WebDriver. It allows commands to be translated through “Selenese” or a Client API. It takes commands across different browsers and platforms at the native operating system level.
• Software complexity continues to increase. The current widely accepted approach to ramping up testing is Selenium wrappers. Wrappers are pieces of code written to encapsulate larger and more complex pieces of code to make them easier to program.

Notice the linear progression of Selenium. You’ll see that the creators keep adding on features piece by piece, incrementally, within the ecosystem. But they have not yet opened the platform up to a scope beyond Selenium practitioners.

Using Selenium is complex and expensive

To fully use Selenium, you need to deploy skilled test engineers. These engineers need to learn the framework, navigate its editions and write test scripts.

The latest version of the platform may allow us to record actions from the UI, but those actions still need to be processed through the backend. The latest approach of wrappers may reduce complexity by abstracting it, but you still need to write code to create the wrappers!  

Using Selenium – the current standard for QA – needs programmers and test engineers. This means spending the scarcest of resources today: time.  

Test maintenance takes time – ask any quality engineer. If you need to write scripts to harness the best features of testing automation, your team can fall into the trap of the test automation paradox. They spend time automating tests, then spend more time maintaining them or fixing them. This results in less time for automating more tests. Test maintenance makes testing always lag behind the exponentially faster development life cycle.

Innovation vs. stagnation?

Innovation in software development has taken it outward, connecting to non-technical business users, across operating systems, browsers, servers and networks. Even across geographies, skill sets, business functions and industries. It is breaking silos, resulting in exponential progress.

But innovation in QA has stayed contained in one ecosystem. It has built on the same bedrock of a very specific skill set, looking only inward. It is circling around the periphery of a two-decade old technology when the rest of the industry (and SDLC) has branched out. In short, it has stagnated. 

AI + QA = Functionize

But it needn’t be like this. Test automation can take the exponential leap it needs simply by adopting AI. Functionize already delivers on this proposition.

Functionize uses machine learning and Deep AI to avoid Selenium’s limitations. Self-healing features help tests evolve in parallel with your application, eliminating test maintenance. The Functionize Test Cloud helps deliver nonstop testing at an unprecedented scale. Architect, our smart test recorder, helps create a rich ML model of your application. It simplifies test creation even for power users. And our visual-testing approach helps bridge gaps between developers and business users. 

The AI era ensures that we no longer have to be satisfied with a linear progression in innovation. QA has been lagging behind the curve, but it doesn’t need to. Book a demo with us to find out how Functionize can help your QA team take an exponential leap in productivity.