Nau mai, haere mai ki te whārangi "Testing"! This page will teach you about testing, a critical step in creating high-quality digital solutions: systematically checking if a computer program or system works correctly and meets its requirements.
Define what "testing" means in digital technologies.
Explain why testing is an essential part of the Design Process (Iterative Development).
Differentiate between testing and debugging.
Identify different types of testing and their purposes.
Understand the importance of testing for an outcome's fitness-for-purpose and end-user satisfaction.
To get the most out of learning about Testing, it's essential to have a clear understanding of:
Computer Program: Do you know that programs are sets of instructions designed to perform tasks?
Debugging: Do you understand how to find and fix errors (bugs) in programs?
Design Process (Iterative Development): Are you familiar with the cycle of planning, creating, and refining digital outcomes?
Quick Check: Imagine you've just baked a new recipe. What's the very last thing you do before sharing it with others to make sure it's good? That's similar to the purpose of testing in digital tech!
Testing (whakamātautau) in digital technologies is the systematic process of evaluating a computer program, digital system, or digital outcome to identify any errors (bugs), confirm that it meets its requirements, and ensure it works as expected for its end-users.
Think of it like a quality check:
Before a car leaves the factory, it's tested to ensure the brakes work, the lights function, and it drives smoothly.
Before a new building opens, it's tested for safety, accessibility, and whether all systems (electricity, plumbing) are working.
Just as these real-world products need to be tested, so do digital outcomes. No matter how carefully a computer program is written, it's very likely to have bugs or unexpected behaviours. Testing helps find these problems so they can be fixed (debugging) before the product is released to end-users.
Testing vs. Debugging:
Testing is about identifying that a problem exists and where it might be. It's asking, "Does this work?"
Debugging is about finding the root cause of the problem and fixing it. It's asking, "Why isn't this working, and how can I make it work?"
They go hand-in-hand: you test to find bugs, and then you debug to fix them. After debugging, you test again to make sure the fix worked and didn't create new issues.
Testing is not a single activity, but a range of methods performed at different stages of the Design Process (Iterative Development) to ensure the quality of a digital outcome.
Common Types of Testing:
Functional Testing:
Purpose: To check if each specific feature or function of the software works correctly according to its requirements.
Example: For a calculator app, functional tests would check if adding 2+2 correctly gives 4, if division by zero shows an error, etc.
Usability Testing:
Purpose: To evaluate how easy, efficient, and satisfying a digital outcome is to use for its end-users. This often involves observing real users interact with the system.
Example: Watching users try to navigate a new website to see if they can easily find information or complete a purchase. This ties heavily into User Interface (UI) and User Experience (UX) Design.
Performance Testing:
Purpose: To check how a system performs under various workloads, including speed, responsiveness, and stability.
Example: Testing how quickly a website loads with many users accessing it at once, or how fast a game responds to player commands.
Security Testing:
Purpose: To identify vulnerabilities in a system that could be exploited by attackers. This helps ensure Computer Security.
Example: Trying to hack into a system (penetration testing from Computer Security page) to find weaknesses before malicious actors do.
Compatibility Testing:
Purpose: To check if the software works correctly on different devices, Operating Systems, browsers, or screen sizes.
Example: Testing a website on a laptop, a tablet, and a smartphone, using different web browsers (Chrome, Firefox, Safari).
Testing is not just done at the very end of a project. It happens continuously throughout the Design Process (Iterative Development).
Early Stages: Testing ideas and designs with sketches or prototypes (e.g., asking users if a basic layout makes sense).
Development Stages: Programmers test small parts of their computer program as they write them (called unit testing). After fixing bugs (debugging), they re-test.
Later Stages: The whole system is tested together, then tested by potential end-users.
Feedback from testing is crucial. Any problems found lead back to debugging and refinement, then more testing, in a continuous cycle of improvement.
Activity 1: Testing a Real-World App
Task: Choose a simple app on your phone or computer that you use frequently (e.g., a calculator, a weather app, a notes app, or a simple game).
Activity:
Create a small "test plan" (3-5 items) for this app. Include things you'd expect the app to do. For example, for a calculator: "Test addition with positive numbers," "Test subtraction with negative numbers," "Test division by zero."
Run your tests. For each test, record:
What you expected to happen.
What actually happened.
Did the test pass or fail? If it failed, briefly describe the bug you found.
Based on your testing, would you consider this app "fit-for-purpose"? Why?
Evidence: Create a Google Doc or Google Slide with your test plan, results, and conclusion.
Activity 2: Usability Test Design
Task: Imagine you've designed a new feature for your school website: a simple online form for students to report lost property.
Activity:
Identify two different types of end-users who might use this form (e.g., Year 7 student, Year 13 student, a teacher).
Design a very short (2-3 steps) usability test task for one of these end-users. (e.g., "Find the lost property form and submit a report for a lost jacket.").
List two specific questions you would ask the user after they complete the task to get feedback on its usability.
Evidence: In a Google Doc, outline your chosen end-user, the usability test task, and the feedback questions.
Check your understanding of Testing.
Multiple Choice: Which statement best describes the difference between testing and debugging?
a) Testing is for hardware, debugging is for software.
b) Testing finds the problems, debugging fixes them.
c) Debugging makes the program faster, testing makes it look better.
d) Testing is only for final products, debugging is only for early stages.
Short Answer: Why is usability testing important for a digital outcome that is designed for end-users?
Scenario: A company is developing a new online game. During development, programmers find and fix many small errors (debugging). Before releasing the game, they decide to let a group of players try it out for a week.
What type of testing are these players primarily performing?
Why is this type of testing important, even after programmers have done a lot of debugging?
Testing (whakamātautau) is the systematic evaluation of digital outcomes to find errors and confirm requirements.
It is distinct from debugging (finding and fixing errors), but they are highly interconnected.
Testing is an essential, iterative process within the Design Process (Iterative Development).
Different types of testing (functional, usability, performance, security, compatibility) serve different purposes.
Effective testing ensures a digital outcome is "fit for purpose" and provides a good User Experience for its end-users.
Now that you understand the vital role of testing in creating quality digital outcomes, you're ready to explore concepts that connect directly to ensuring accuracy, reliability, and excellent user interaction:
User Interface (UI): Discover how the visual and interactive design of a system directly impacts how easy it is to test and use.
User Experience (UX) Design: Explore the broader field of ensuring a positive overall experience for users, which heavily relies on testing and feedback.
Design Process (Iterative Development): Revisit this overarching concept to see how testing (and debugging) are continuous cycles throughout the entire development journey.
Computer Program: Apply your understanding of testing as you build and refine more complex programs.
Algorithms: Consider how rigorously testing an algorithm ensures it always produces the correct results.
Continue your journey by clicking on the links to these exciting topics!