Automation Software Development Process

Share on facebook
Share on linkedin
Share on whatsapp
Share on email
Share on print
In this article, you can read about our tester automation software development process. You, as our client, are a big part of this process, as it is meant to provide you with the solution you need.

The purpose of automation is to automate a process currently done manually by an operator.

The key benefits of process automation are:

  1. Shorten process time
  2. Reduce probability of human errors
  3. Improve process reliability and reputability
  4. Work around the clock with minimal to no human intervention

Automatic machines need a software to run them. The development of automation software requires time and engineering skills.

To achieve the goals listed above and more, we at Testview follow the following development process, that is meant to make sure that the developed software answers the needs and the problems that you, the customer, is facing. This process is comprised of several stages.

Stage One: Software Requirements

To make your software requirements clear, a software requirements document is drawn up. Meaning, a technical definition of the way the software should work, and a detailed description of all its required features, is written. Its purpose is to figure out how the software should operate in general, and what is expected from everyone involved.

The software requirements must include:

  • The way the GUI (graphic user interface) will look – a blueprint of the way the client envisions the UI is often attached
  • The expected user experience – what will the user be able to click on, for example
  • The required inputs and outputs – an input will be the parameters that the user will have to put in, for example, and an example of an output would be a report of the test results
  • The hardware involved – it is very important to know from the get-go what hardware the software is going to have to interface with – it makes the software development process more focused.
  • The process that we are automating – a detailed description of the testing procedure and the steps performed during each test, in our case.

It is also important to set a clear, well-planned schedule. Sometimes the expectations for the development process of a product are unrealistic – well-defined, realistic, and experience-based schedule will prevent a lot of unnecessary frustration.

Stage Two: Formulation of the Software Interface

Because everything that stands behind the GUI is meant to support it, it is very important that everyone working on the project will be on the same page regarding it. Most of the time the customer has a clearer vision of how the software interface will look. An engineer will sit down with the customer and create a draft of a software interface, based on the details and blueprints provided in the software requirements document. This interface does not have any software code behind it, and it is simply meant to show the client what the software will look like, using LabVIEW™ Front Panel. We will also manually create results and supporting files to define the specifics of the outputs the software will generate.

Stage Three: Simulated Software

After the UI’s design is approved by the customer, the next stage is to get a feeling of the software user experience. This is done by “animating the software” – getting the software to work in simulation mode. This stage is split into two steps:

  1. Writing the supporting code to the software UI we created in the previous stage, and getting the software, with all its buttons, controls, indicators, graphs, dialog boxes, and more, to a fully functional state. We will use simulated data and will not communicate with any hardware yet.
  2. Our next step is to get each process in the simulation to work in a way that supports the required inputs and outputs – so, for example, the software will generate a report during the simulated run.

The customer (and we) will get a complete feeling of the software, and we can fine-tune it without being dependent on hardware availability and performance. Because simulations take less time to run than actual tests on actual hardware, simulated debugging will save us time and allow us to solve software bugs faster.

Stage Four: Integration

After the software is fully approved, the hardware is integrated into it. Integration is what allows users to control the hardware through the developed software. This stage involves both hardware and software. The integration process is much easier when the developers know exactly what they need the hardware to provide them with. This is why it is important to provide a list of the hardware involved from the very beginning – the software will be developed to support the required hardware from the get-go.

Stage Five: Validation

This stage is meant to validate the system’s performance. The service providers hand over the first version of the software to the client. The client then checks if everything works properly in his environment. This stage, like all previous ones, involves a back-and-forth with the client, in which he lists problems, comments, and requests, and the developers perform a round of improvements.

At the end of this stage, the client has in his hands a working automation software, tailored to his requirements.

Testview – Your LabVIEW™ Software Development Partners

Testview provides LabVIEW™ programming and software development services. Our software development process is meant to make sure that our customers receive the software they need, on time and on budget. Our team of developers have experience with hundreds of proven LabVIEW™ applications, and a lot of already tested code they can reuse, to make the process simpler, and quicker. To read more about the services we offer regarding LabVIEW™ programming and software development, click here.

 

shopping cart

Your cart is currently empty.

Return to shop