Build Better Apps With a Low-Code Development Approach

From being an option, DevOps is quickly turning into a necessity for most businesses in recent times. DevOps enables businesses to seamlessly collaborate between various cross-functional teams, deliver features faster, and reduce release failures while optimizing resources to the core. To fully leverage the DevOps revolution, IT, business, development, and quality teams should work on the same page. Low-code development is a new approach that enables technical and non-technical members to work together on software development projects to meet changing IT demands.

An overview of low-code development

Low-code development is a new software development approach that enables developers to quickly build software using visual user interfaces that are augmented by model-driven logic while eliminating the need to hand code apps. Users can simply drag and drop code using pre-built templates and code snippets. This approach not only expedites the development process but also enables people with varying programming skills to seamlessly collaborate and contribute to code development.

The evolution of low-code development

Right from the assembly, languages that dealt with zeros and ones to the current easily-readable coding languages, software development has come a long way. In the beginning, assembly languages were used to write computer programs. These programs were easy to understand for the computers but were highly complex for developers as they had to deal with binary coding systems, involving zeros and ones.

In the 1950s, assembly languages such as COBOL and FORTRAN ruled the software world. These languages worked closely with the architecture and hardware of the system. The 1960s saw the introduction of SNOBOL which was an extension of COBOL. Later in the 1970s, the C language was introduced which became highly popular. At the end of that decade, Object Oriented Programming System (OOPS) was added to C. SQL also came into existence in this period which enabled users to manage data.

In the 1980s, FoxPro and MATLAB became popular. While FoxPro dealt with DBMS, MATLAB was used for algorithms and visualizations. The period between 1990 and 2000 saw the introduction of popular languages such as Java, Python, PHP, and Ruby. JavaScript extended Java to manage UI aspects. The new decade saw C# rise to popularity for web and desktop app development. It was followed by languages such as Go and Rush. With the proliferation of mobile devices in the current decade, Kotlin became popular for Android OS while Swift dominated the iOS segment.

The reason for this transition from hardware-associated assembly languages towards user-centric programming languages is to reduce complexity in coding, make the code clean, and improve performance and productivity.

Programs written in assembly languages involved complex code and were hard to understand for the developers. For instance, look at a simple addition program written in an assembly language:

The same code gets simpler in Java:

Influence of programming languages

Current programming languages are influenced by earlier ones. For instance, the most popular language Java was inspired by C++ and Smalltalk. Interestingly, both Smalltalk and C++ were influenced by Simula. C++ is an extension to the C language, though. C and Pascal were influenced by Algol 68 which was actually influenced by Algol 60. Pascal influenced Modula and ML and ML influenced Haskell.

What makes programming languages successful?

For a programming language to become successful, the core requirement is that it should solve a problem. For instance, C comes with efficient system programming while JavaScript can reside inside a browser. In addition, productivity and performance are key requirements. It should come with a good environment with an interpreter and compiler, influential designers while being secure. Obviously, portability makes it popular.

Visualization of code

In a way to simplify coding, developers tried codeless development methods such as visualizing the code using flowcharts.

In 2000, Mercury introduced the Keyboard view model that simplified code visualization.

Why did the ‘old’ codeless methods fail?

While the old codeless methods made code easy to understand, it did not reduce the complexity. When the code logic got complex, visual presentations got complex too. Scaling and refactoring of code was a challenge too. The absence of good version control systems and other collaboration tools added up to the failure.

Behavior-driven development

Behavior-driven development (BDD) is another alternate approach that combines code and codeless methods to simplify the development process. Cucumber is a popular BDD tool.

In this method, user stories are created for each scenario, and code snippets are written for that scenario, and then each user story is mapped with the specific code snippet.

There are three main components in this method:

• The feature talks about a specific functionality using a high-level description
• Scenario converts the behavioral specification into examples and formal steps
• Executable specifications talk about the Given, When and Then Agile Syntax

For instance, when you are testing the performance of a login feature in a demo app: Eribank application

The non-developers will write a scenario for the feature as follows:

1. @AddScenario
2. Scenario: Login to Eribank Application
3. Given: Input Credentials
4. When Click the Login Button
5. Then Check Login

Now the test automation engineers will create the code for each action using a programming language and map each action with the corresponding code snippet.

Model-based testing

To incorporate the best coverage for your test automation projects, understanding and analyzing requirements is the key. Without an automated system for requirements gathering, your initial test automation phase becomes inefficient. Model-based testing solves these challenges and lets you fully leverage the test automation with minimal test cases.

Model-based testing is an important part of your software development life cycle. In this approach, models that capture the behavior of a system are created. They describe test strategies, environments, generate test cases, and assess the quality of tests.

First of all, a model that captures the system behavior under test is created. Then the model-based tool will analyze and interpret this behavior to create manual and automated test scripts.

The challenge with the MBT approach lies in creating and maintaining the model. You need to create a mapping of the model as well. For instance, when you create a model for the login function, you need to create the logic that takes you to the next screen. Similarly, you need to identify changes.

Digital.ai Continuous Testing integration with low-code development platforms

Digital.ai Continuous Testing is a comprehensive cloud test automation platform that enables you to run a variety of test cases on a range of devices and browsers located across different regions. Now, Digital.ai Continuous Testing enables you to integrate low-code development platforms to run model-based testing

Digital.ai Continuous Testing test automation cloud platform offers an artificial intelligence (AI) bot that solves the model-based testing challenges by combining the AI power with human inputs.

Here is a demo

When you log in to the Digital.ai Continuous Testing account and click on Devices, you can see a list of devices available for the test.

Now, click on a device:

Go to Apps and install a demo banking application, ERIBANK

After the app is installed, launch the application.

When you click on the login button, it gives an error message prompting for username and password.

If you provide the username and password, it will take you to the next screen.

So, without the username and password, you don’t have much to test here. so, you need to find ways to perform more tests.

Digital.ai Continuous Testing AI bot application will help you do so.

So, open the AI application page and click on create a new project.

Enter a project name and click next.

On the next screen, you need to select the application.

You can either upload the app or choose from the cloud repository and then click on Create Project.

Now, click on Start Exploration. The AI bot will start exploring the application.

On the next screen, provide a name for the exploration and then select the devices for the exploration. For this demo, 4 devices are selected.

Now, exploration has started.

When you go to the Digital.ai Continuous Testing dashboard and click on devices, you can see that 4 devices are running the test.

Now, go to the AI bot page and click on Gates. You can see that the bot has already identified a gate.

When you click on unlock, you can check the details of the gate. Here, it is showing the login screen and it needs your help to unlock the login screen.

There are two ways to provide this information. You can either write a code snippet using Appium/Selenium code or simply fill out this small form with the user credentials as follows:

• Username=>company
• Password=>company
• Login=>

Now, click on save.

Now, you can see that the gate is unlocked.

Now, go to the Explorations tab and click on the exploration name. You can see the exploration activity in a graphical format.

Now, the bot will take the information and continue exploration. When the user credentials are provided, it will pass through the login screen and enter into the next screen. The other workers will take this information and perform various test activities on the applications, distributing the testing time among themselves.

Here, you can see that each device is running a different test checking a different screen and functionality.

If you check the graphical view of the exploration now, you can see a bigger graph with multiple activities.

If you check the gates tab now, you can see that it has identified more gates. (eg: MakePaymentActivity, MortageRequestOneActivity)

For instance, click on Unlock and provide information for making a payment.
Phone=>111
Name=>guy
Amount=>100
Select=>india=>
Send=>

And click on save. Now, the bot will take this information to unlock the payment gate and perform more explorations.

Now, click on save.

You can see that the new gate is unlocked. If you now check the graphical view of the exploration, you can see that the graph is extending.

You can see all the connections between the screens and the logic behind the application functionality in a GUI view. Execution analysis is collected as well for different use cases.

Test AI bot use cases 

This model-based AI test automation approach solves several challenges. Here are the important ones:

Manual and automation helper 
The Application navigation helper feature enables you to start your application in the desired state. It means you start with any screen of the application. Similarly, the automation helper enables you to find the UI tree view (dump) of any screen of the app. For instance, if you are an Appium developer, you can easily find the Xpath elements as the entire model is saved here.

App crash identification 
This AI application comes with an App crash identification test. When you scale the model and execute the test on thousands of devices with different versions, manufacturers, screen sizes, and resolutions. It will identify app crashes and anomalies of your app. You can also perform a smoke test.

Application insight 
After an exploration is done, the tool will also provide the test analysis.

Here you can see some test insights. For instance, it will provide a summary of the overall UX Score. In addition, it will provide performance anomalies.

In this demo, it shows that the

• Login is slower in version 2.14.
• iOS 14.1 is behaving differently in the money transfer screen.

Another insight is that a new activity is identified in version 2.34. so, it automatically identifies screen changes in the app under test.

Automation helper 
If you are using Appium, the tool will enable you to navigate to the desired place in the model and execute the code from that area. It means you can significantly reduce the Appium navigation code, reduce the amount of code and in turn reduce the complexity of the code as well. In addition, it allows you to efficiently handle unexpected pop-ups and events using the XPath Listener capability.

Summary

To fully leverage the model-based testing approach while eliminating its challenges, Digital.ai Continuous Testing comes integrated with an AI-powered model-based testing tool. This approach combines the AI bot with a human being so that they work together to build a model for test automation projects. With application autonomous exploration along with fast application graph creation, it enables test engineers to quickly generate and run automated tests on a model and analyze test results. While the AI bot performs most of the explorations, it requires human assistance to unlock certain gates such as Login screens.

Now build better applications faster with this low-code development approach!

To see more watch the full low code development webcast here.