# 2.1 Computational Artifacts A computational artifact is a human-made object or system created using computational thinking. These are byproducts of software development and serve as tangible expressions of ideas or solutions to problems. *Examples*: Programs, websites, videos, simulations, databases, digital animations, software systems, e-commerce platforms, and mobile applications. ## Computational Artifacts in Software Development Computational artifacts are crucial objects that help describe the architecture, design, and function of software *before* the coding phase begins. They simplify the development process by defining the software's behavior through control sequences, allowing developers to understand its logic without delving into complex code. This is often a part of the . ## Computational Solution Design Commonly used computational artifacts for designing solutions include algorithms, flowcharts, and pseudocode. | Artifact | Description | Representation | | :--- | :--- | :--- | | **Algorithm** | A step-by-step set of instructions in natural language that defines how a problem should be solved. | Plain text, numbered steps. | | **Flowchart** | A visual representation of an algorithm's flow and logic using defined symbols. | Diagrams with shapes and arrows. | | **Pseudocode**| An intermediate step between an algorithm and actual code using simplified programming constructs. | Text-based, structured like code. | ### Example: Check if a number is Even or Odd - **Algorithm:** 1. Input a number, let's call it `num`. 2. Check if `num` is divisible by 2. 3. If the remainder is 0, output "The number is even." 4. If the remainder is not 0, output "The number is odd." - **Flowchart:** - **Pseudocode:** ``` // Step 1: Input a number Input "Enter a number: " into num // Step 2: Check if the number is even or odd if num % 2 = 0 then // Step 3: Output result for even number Output "number is even." else // Step 4: Output result for odd number Output "number is odd." end if ``` ## Planning and Developing a Computational Artifact The process involves several key steps, often requiring to break down complex tasks: 1. **Define the problem**: State the problem clearly. 2. **List inputs and outputs**: Identify the information needed (inputs) and the expected result (outputs). 3. **Plan**: * *Outline the logic*: Break the problem into smaller, manageable parts. * *Choose Data Structures*: Select appropriate ways to store and organize data (e.g., ). * *Choose Control Structures*: Select methods to control the order of execution (e.g., conditional statements or loops). 4. **Development**: Describe the steps to transform inputs into outputs. Refine these steps until they are clear and computable. This is an **iterative** process. 5. **Test the algorithm**: Verify the algorithm with various data sets to ensure it works correctly. ## Testing Computational Artifacts Testing is an iterative process to find and fix potential logical errors, often referred to as . - **Algorithm Tracing**: Also known as a "desk check" or "dry run," this is the process of manually simulating the execution of an algorithm to verify its logic and track variable values before writing code. - **Trace Tables**: A technique used for algorithm tracing. A trace table shows how variable values change at each step of the algorithm. ### Example: Trace Table For the following pseudocode: ``` 1. number = 3 2. PRINT number 3. FOR i from 1 to 3: 4. number = number + 5 5. PRINT number 6. PRINT "?" ``` **Trace Table:** | Pseudocode Step | number | i | Output | | :-------------- | :----- | :-- | :----- | | 1 | 3 | | | | 2 | 3 | | 3 | | 3 (start loop) | 3 | 1 | | | 4 | 8 | 1 | | | 5 | 8 | 1 | 8 | | 3 (next iter) | 8 | 2 | | | 4 | 13 | 2 | | | 5 | 13 | 2 | 13 | | 3 (next iter) | 13 | 3 | | | 4 | 18 | 3 | | | 5 | 18 | 3 | 18 | | 6 | 18 | 3 | "?" | ## Algorithm Evaluation Parameters Algorithms are evaluated based on several key criteria to ensure they are optimized for a : - **Correctness**: The algorithm must produce the correct output for all valid inputs. - **Efficiency**: How well the algorithm uses resources. - *Time Complexity*: The amount of time an algorithm takes to run. - *Space Complexity*: The amount of memory an algorithm requires. - **Clarity**: How easily the algorithm's logic can be understood by humans. - **Reliability**: The ability of the algorithm to consistently produce correct and accurate results.