As mentioned earlier, all interpretations and uses – i.e. decisions – are subject to a number of assumptions. For example, if we interpret the results of a virtual reality assessment, we might assume that the simulation task – including visual representation, simulator control, and the task itself – is relevant to tasks of clinical importance. the evaluation algorithm takes into account important elements of this task; there are sufficient tasks and sufficient diversity between tasks to reliably measure trainees` performance; and that it is advantageous to require trainees to continue practicing until they reach a target score. These and other hypotheses can and should be tested! Many assumptions are implicit, and recognizing and explaining them explicitly before evidence is collected or studied is an essential step. Once we have specified the intended use, we must (a) identify as many hypotheses as possible, (b) prioritize the most worrisome or questionable assumptions, and (c) develop a plan to gather evidence that confirms or refutes the accuracy of each hypothesis. The resulting hierarchical list of hypotheses and desired evidence represents the argument for interpretation and use. Specifying the interpretation-use argument is both conceptual and important for providing a research hypothesis and articulating the evidence needed to empirically test this hypothesis. This reflective exercise highlights two important points.
First, the argument of interpretation and use may change as the decision changes. Second, an instrument is not “valid” per se; Rather, it is the interpretations or decisions that are validated. A final judgment on validity based on the same evidence may be different for different proposed decisions. Once the detailed test requirements are developed, test developers can design and implement a test system that covers the requirements. Once completed, engineers must ensure that the test system covers all defined requirements. The process of ensuring that the test system correctly meets the specified requirements is called verification. Verification is the process of determining whether a test system has been created in accordance with the specifications of a design, drawing, service description, or other similar policy. TestStand calls code modules to communicate with instrumentation and automation hardware. Code modules can be implemented in a number of languages, including LabVIEW, C++, or C#. Because TestStand provides a natural boundary between steps and code modules, it is advantageous to write code modules that can be tested and validated independently of the TestStand sequence. To ensure that code modules can be tested outside the test sequence, avoid using SequenceContext or other TestStand references to access the data directly, and then pass the data to the code module through parameters instead. In cases where the use of SequenceContext is required, such as implementing a scheduling monitor, design the code module so that it can run without testStand-specific code.
In a LabVIEW code module, you can use the “not a reference” function to verify that the SequenceContext is valid before it is used. Because people have different values, normative statements often cause disagreement. An economist whose values lead him to conclude that we should provide more help to the poor will disagree with someone whose values lead to a conclusion that we should not. Since there is no test for these values, these two economists will continue to disagree unless one persuades the other to adopt a different set of values. Many of the disagreements between economists are based on such differences in values and are therefore unlikely to be resolved. To combine the benefits of composing built-in step parameters with the extensibility of using separate steps, you can create subsequences to encapsulate sets of related steps. By including sets of these sequences in a separate sequence file, you can efficiently create a sequence file, which is a library of functions that can be independently validated and shared by multiple test applications. In addition, the test sequence should consist almost exclusively of sequence call steps.
each of them implements a logical grouping of tests. The organization of sub-sequences should be mapped to the test specifications, with high requirements such as “The system must test the audio capabilities of the device” mapped to a sequence in the test, while lower media requirements such as “Maximum sound volume should not exceed 80 dB” should be mapped to the sequence steps. To maintain a consistent set of software on a test system, you must create a base image from a validated system and use that image when configuring new test stations. But even when you use an image, you need to make sure that no software updates occur. For NI software, make sure that NI Update Service is configured so that updates are never installed automatically. By default, Microsoft updates run automatically on most computers. Other companies such as Sun, Apple, and Adobe also use web-based automatic updates. You must disable all automatic changes and upgrades on all systems subject to V&V processes. Changes made by automatic updates are unpredictable and can have unknown effects on operations and settings. To do this, it is important to ensure that each component is completely decoupled from the other components and has independent validation procedures. For example, you can introduce a hardware abstraction layer (HAL) that provides a standard set of features to interface with the hardware.
The functions defined by the HAL can be validated independently of the rest of the test system. When you make a hardware change, the effect affects only the HAL layer because you can verify that the HAL functions behave the same way after the change. When maintaining a test system, you should consider upgrading LabVIEW, TestStand, or another program to take advantage of new features as they become available. Such a software upgrade is always a trigger for revalidation and reverification. Treat a potential upgrade as a return on investment (ROI). For example, to get an optimized development interface, you can upgrade during development, but not after you deploy the system. However, as with recent TestStand upgrades, improved execution speed can result in shorter test time, higher throughput, and higher revenues. In both cases, the cost of revalidation is the deciding factor, but the cost can also generate a positive return on investment and is therefore worth it.
Typically, multiple software upgrades should be performed simultaneously to minimize the frequency of software validation.