The goal of any development team is to produce a high-quality product. Quality, in this sense, is defined as value to a stakeholder. At Kinaxis, quality is then defined as providing accurate, rapid insights into a customer’s supply chain – managing everything from a broad overview of their entire supply chain right down to individual parts in a warehouse.
In pursuit of quality, testing is regarded as a critical step of the software development process. But what is testing? And how does it improve the overall quality of a product?
In short, testing is the act of finding and reporting bugs in the product. The fewer bugs, the higher the quality. What is a bug? A simple definition of a bug is ‘a defect or unwanted functionality within the product’. That definition is tautological – both ‘defect’ and ‘unwanted functionality’ are simply synonyms for ‘bug’. A better definition relies on the end-goal of the development process itself. Therefore, if the goal is a high-quality product, and quality is the value to a customer; then a bug can be usefully defined as any impediment to a customer accomplishing their objective, thus reducing the product’s value to that customer.
Clearly, these bugs must be found as early as possible and dealt with accordingly. Testers must seek out these bugs no matter where in the build they’re hiding, so what’s the best way to go about finding them?
The art and science of testing
To start, we need to go right to the beginning of the build.
There’s an art to testing, especially in consulting with the other stakeholders for thorough discussions on how to blend their different visions into a unified reality. This process is known as ”validation“ – ensuring the right product is built. It requires soft skills to ensure all concerns and needs are listened to, understood and incorporated.
Next comes the more rigorous process: the science. The science of testing is the ability to examine the product with clarity – to see what the product does without blinders or preconceptions – by meticulously dissecting it. This process is known as “verification,” or ensuring the product that was built functions correctly.
At Kinaxis, testing always starts with validation. Testers are involved at all stages in the development process, starting from the very beginning with creating feature requirements. To do so, testers look at the overall product to assess how features interact with each other and take note of possible issues or areas of improvement. An inquisitive nature helps in this regard. Asking questions that may seem obvious, such as “what is a user?” can lead to discussions about requirements (such as roles and access permissions) that were not previously considered as part of the feature.
This initial process of assessing a feature’s design is critical to writing clear requirements, which is vital to ensure the correct functionality is being developed. By validating the product early, testers can catch bugs before they’re created.
Validation continues throughout the development process. As the feature begins to take shape, testers start the exploration process – often called exploratory testing. When exploring a feature, it’s inevitable that someone will take a slightly different path to perform an action. Such deviations expose scenarios that were not analyzed during the design stage. Continuous development creates continuous new (and potentially unexpected) interaction between features. Communicating these discoveries creates a feedback loop with other stakeholders that ensures the feature is polished before it’s finished.
The power of verification in automation
When the development of a feature starts to close, it becomes possible to design rigorous tests to thoroughly cover all aspects of the requirements. These tests ensure that the agreed upon requirements hold true now and into the future. A variety of tests are required for this, and are typically automated and run with every build.
The result is that stakeholders at Kinaxis are given continuous feedback about whether all feature expectations are met with every build of RapidResponse. A robust suite of automated tests is ideal, but automated tests are only as good as the validation that preceded them. By focusing on validation up front, Kinaxis can have a high degree of confidence in its automated testing suites.
Kinaxis’ motto, “Know sooner. Act faster. Remove waste” applies just as well to its skilled testing teams. Validation enables us to know about potential bugs sooner. Verification in automation allows us to act faster. By listening to the information revealed, we can remove wasteful bugs from the product.
Our dedication to delivering the best product is clearly baked into our development process, and we’re excited to see what we will do next.