Teaching Content for General Objectives:

---

General Objective 1: Develop Cognitive Skills to Solve Problems

1.1 Introduction to Cognitive Problem-Solving

Cognitive problem-solving involves using your thinking and reasoning skills to identify, analyze,
and find solutions to problems. These skills are crucial for everyday decision-making, as well as
for tackling complex problems on the computer.

1.2 Stages of Cognitive Problem-Solving

1. Problem Identification:

The first step is to clearly identify the problem you're trying to solve.

Example: A website crashes every time you click a certain button.

2. Understanding the Problem:

Break the problem into smaller parts and analyze it. Ask critical questions like:

What is causing the problem?

Is it happening under specific conditions?

3. Information Gathering:

Gather all the information that can help solve the problem, such as data, past experiences, or
expert advice.

Example: You might check error logs or search for similar issues reported by others.

4. Idea Generation (Brainstorming):

Generate multiple possible solutions. Don't focus on finding the "perfect" solution
immediately—explore different ideas.

Example: Consider whether the problem is related to browser compatibility, the code, or server
settings.

5. Decision-Making:

Evaluate each potential solution by weighing the pros and cons. Then, select the solution that
best addresses the problem within the given constraints.

Example: You might decide to fix the code first before testing other possible solutions.

6. Implementation:

Implement the solution you’ve decided on and monitor its effectiveness.

Example: After fixing the code, run the website again and test the button to see if the issue
persists.

7. Evaluation:

Evaluate the outcome. Did the solution work? What did you learn from the process? If
necessary, repeat the steps to refine your solution.

Example: If the website still crashes, go back to information gathering and try another solution.

1.3 Activities to Enhance Cognitive Problem-Solving

Critical Thinking Exercises: Students can practice solving logical puzzles, case studies, or
real-world problems.

Group Discussions: Discussing problems in groups helps develop cognitive flexibility and
introduces different perspectives.
Activity Example:

Task: Present students with a common real-world problem (e.g., slow computer performance).
Ask them to go through the cognitive problem-solving steps to figure out the cause and develop
possible solutions.

---

General Objective 2: Develop Competence in Applying a Structured Approach to Solving

Problems on the Computer

2.1 Introduction to Structured Problem-Solving on the Computer

A structured approach to problem-solving on the computer involves following a clear,

step-by-step method to tackle technical issues. This ensures problems are solved efficiently and
thoroughly.

2.2 The Structured Problem-Solving Approach

1. Understand the Problem:

Clearly define the problem you're trying to solve and understand the requirements.

Example: A program is not running as expected; identify where it fails and what its expected
output should be.

2. Plan the Solution (Algorithm Design):

Outline the steps required to solve the problem. This is often done by developing an algorithm
or flowchart.

Algorithm Example:

Step 1: Get user input.

Step 2: Process the input (perform calculations or actions).

Step 3: Display the output.

3. Break Down the Problem into Smaller Steps:

Large problems can be overwhelming. Break them down into smaller, more manageable tasks.

Example: If you’re building a calculator, first work on the addition function, then subtraction, and
so on.

4. Write the Code or Use Tools:

Translate your plan into code or use appropriate software tools to execute your solution.

Example: If you’re solving a programming problem, write the code that follows your algorithm.

5. Test the Solution:

Test your solution with different inputs to ensure it works correctly.

Example: Input various numbers into your calculator to see if it performs all operations correctly.

6. Debug and Refine the Solution:

If there are any errors, use debugging techniques to find and fix them. This involves identifying
the cause of the error, analyzing why it occurred, and making necessary changes.

Example: If your calculator gives incorrect results, check the code for mistakes in your formulae.

7. Document and Reflect:

Document your solution and reflect on the process. Consider how you could improve it next
time.

Example: Comment your code and summarize the problem-solving process for future reference.
2.3 Activity Example

Task: Ask students to write an algorithm and code for a simple program (e.g., a temperature
converter that converts Celsius to Fahrenheit). Students will follow the structured
problem-solving approach from planning the solution to testing and debugging.

---

Video Resources:

1. Cognitive Problem-Solving Techniques:

5 Steps to Problem Solving

2. Structured Problem-Solving Approach for Programming:

How to Approach Problem Solving in Programming

3. Writing Algorithms:

What is an Algorithm?

4. Debugging Techniques:

Debugging in Programming

---

This teaching content focuses on developing students’ cognitive problem-solving skills and
teaching them a structured approach to solving problems on the computer. By following a
logical, step
Teaching Content for Specific Objectives

---

Objective 1: Outline the Steps in Problem-Solving

1.1 Introduction to Problem-Solving

Problem-solving is a critical skill in both personal and professional contexts. It involves

identifying issues, analyzing information, and developing solutions. Understanding the
systematic steps in problem-solving can help streamline this process and make it more
effective.

1.2 Steps in Problem-Solving

1. Identify the Problem:

Clearly define what the problem is. Make sure to understand the context and the specific issue
that needs to be resolved.

Example: Your computer is running slowly.

2. Gather Information:

Collect relevant data and details about the problem. This may involve asking questions or
conducting research.

Example: Check for running applications, system performance, and recent changes made to the
system.

3. Define the Goals:

Establish what a successful resolution would look like. What are the desired outcomes?

Example: The computer should operate smoothly without lag.

4. Generate Possible Solutions:

Brainstorm multiple solutions to the problem. Encourage creative thinking and consider all
possibilities.

Example: Potential solutions could include closing unnecessary applications, upgrading

hardware, or performing a system cleanup.

5. Evaluate and Select a Solution:

Assess the feasibility, advantages, and disadvantages of each potential solution. Choose the
most effective and practical option.

Example: After evaluating, you might decide that closing unnecessary applications will provide a
quick fix.

6. Implement the Chosen Solution:

Put the selected solution into action. This may involve a series of steps to ensure it is executed
correctly.

Example: Close all unused applications and check if performance improves.

7. Monitor and Review the Results:

After implementation, monitor the situation to see if the problem has been resolved. If it hasn't,
re-evaluate the situation and consider other solutions.

Example: Observe if the computer’s performance improves after the applications are closed.

8. Reflect on the Process:

Consider what worked well and what could be improved in your problem-solving approach.
Document lessons learned for future reference.

Example: Did closing the applications solve the issue? If not, what else could be done?
Activity Example:

Task: Present students with a case study (e.g., a team project that is behind schedule). Have
them work in groups to identify the problem, gather information, and outline a problem-solving
strategy following the steps listed above.

---

Objective 2: Use the Divide-and-Conquer Approach to Decompose Large Everyday Problems

into Smaller Tasks

2.1 Introduction to Divide-and-Conquer

The divide-and-conquer approach is a problem-solving strategy that involves breaking a large

problem into smaller, more manageable parts. This technique helps simplify complex tasks and
makes them easier to tackle.

2.2 Steps in the Divide-and-Conquer Approach

1. Define the Overall Problem:

Start by understanding the big picture and clearly define the large problem that needs to be
solved.

Example: Planning a wedding.

2. Break the Problem into Smaller Sub-Problems:

Identify the major components or tasks that contribute to the overall problem. Each component
should be a smaller, independent task.

Example: A wedding can be broken down into smaller tasks such as:

Budgeting

Venue selection
Guest list management

Catering

Invitations

3. Analyze Each Sub-Problem:

For each smaller task, analyze what needs to be done to complete it. This may involve
additional research or identifying resources.

Example: For the venue selection, you may need to:

Research potential venues

Visit selected locations

Compare prices and availability

4. Develop Action Plans for Each Sub-Problem:

Create specific action plans for tackling each sub-task. Define clear steps and deadlines for
completion.

Example: The action plan for catering might include:

Research catering services by next week.

Schedule tastings by the end of the month.

Finalize catering by six weeks before the wedding.

5. Execute the Action Plans:

Start working on each of the smaller tasks according to the developed plans.

Example: Begin contacting venues and catering services as per the timelines established.

6. Monitor Progress:

Keep track of the progress on each sub-task to ensure everything is on schedule. Adjust plans
as necessary.

Example: Regularly review the status of each task in the wedding planning process.

7. Integrate the Solutions:

Once all sub-tasks are completed, integrate them to achieve the overall objective.

Example: Ensure that all arrangements are synchronized for the wedding day.

Activity Example:

Task: Ask students to select a complex everyday problem (e.g., organizing a community event).
Have them apply the divide-and-conquer approach to break the problem down into smaller,
actionable tasks and create a timeline for each.

---

Video Resources:

1. Problem-Solving Steps Explained:

Problem Solving Steps

2. Using the Divide-and-Conquer Approach:

Divide and Conquer: A Problem Solving Technique

3. The Importance of Problem-Solving:

Problem Solving Techniques

4. Critical Thinking and Problem Solving:

Critical Thinking and Problem Solving Skills

---

This teaching content covers the essential steps in problem-solving and introduces the
divide-and-conquer approach as a structured method for tackling complex problems. Through
activities and video resources, students can develop practical skills to analyze and solve
real-world problems effectively.

---

Objective 3: Define a Problem by Decomposing It into Its Significant Components

3.1 Introduction to Problem Decomposition

Decomposing a problem involves breaking it down into smaller, manageable parts or

components. This approach helps clarify the nature of the problem, making it easier to analyze
and solve.

3.2 Steps to Decompose a Problem

1. Identify the Overall Problem:

Begin by stating the problem clearly and concisely.

Example: “Sales have decreased significantly over the last quarter.”

2. Break Down the Problem into Major Components:

Analyze the problem and identify its significant components or factors contributing to the issue.

Example: The components could include:

Market Conditions: Changes in customer preferences or economic factors.

Product Issues: Quality problems or lack of new features.

Sales Strategies: Ineffective marketing tactics or reduced outreach.

3. Further Decompose Each Component:

Take each major component and break it down further into smaller, specific issues.

Example:

For Market Conditions:

Changes in competitor pricing.

Shifts in customer demographics.

For Product Issues:

Customer complaints about product features.

Delay in launching a new product.

4. Analyze the Relationships Between Components:

Understand how these components interact and contribute to the overall problem.
Example: Determine if a decrease in sales correlates with product issues or market conditions.

5. Document the Decomposition:

Create a visual representation, such as a flowchart or mind map, to illustrate the components
and their relationships.

Example: Use a mind map to show how each component leads to the overall issue of
decreased sales.

Activity Example:

Task: Provide students with a complex problem scenario (e.g., a school facing declining
enrollment). Have them work in groups to decompose the problem into its significant
components and present their findings to the class.

---

Objective 4: Distinguish Between Variables and Constants

4.1 Introduction to Variables and Constants

Understanding the difference between variables and constants is fundamental in mathematics,

programming, and scientific research. Variables are elements that can change, while constants
remain fixed throughout a problem or experiment.

4.2 Definitions

1. Variables:

Definition: A variable is a symbol or name that represents a value that can change or vary.
Variables are often used to store data or values that may be updated or modified throughout the
course of a problem.

Example: In the equation , both (slope) and (input) are variables that can take different values,
affecting the value of .
2. Constants:

Definition: A constant is a value that does not change or vary. It remains the same throughout
the analysis or calculations.

Example: In the same equation , (the y-intercept) can be considered a constant if it does not
change during the analysis.

4.3 Types of Variables:

Independent Variables: The variable that is changed or controlled in a scientific experiment.

Example: In an experiment testing plant growth, the amount of sunlight is an independent

variable.

Dependent Variables: The variable that is measured and affected in the experiment.

Example: In the same experiment, the growth of the plant (measured in height) is the dependent
variable.

4.4 Visual Representation:

Use tables or charts to illustrate examples of variables and constants in different scenarios,
such as programming, mathematics, and scientific experiments.

Activity Example:

Task: Provide students with various equations and scenarios (e.g., temperature conversion,
simple physics problems) and ask them to identify and classify the variables and constants
present in each.

---
Video Resources:

1. Decomposing Problems:

How to Break Down a Problem into Parts

2. Understanding Variables and Constants:

What Are Variables and Constants?

3. Problem Decomposition Techniques:

How to Decompose a Problem

4. Variables vs. Constants Explained:

Difference Between Variables and Constants

---

This teaching content provides a structured approach to defining problems through

decomposition and clarifies the distinctions between variables and constants. Engaging
activities and video resources will enhance students' understanding of these concepts and their
applications in various fields.

---

Objective 5: Explain the Concept of Algorithms

5.1 Introduction to Algorithms

An algorithm is a step-by-step procedure or formula for solving a problem. It is a finite set of

instructions that, when followed, leads to a specific outcome or solution. Algorithms are
essential in various fields, especially in computer science and mathematics, as they provide a
systematic approach to problem-solving.
5.2 Key Characteristics of Algorithms

Clear and Unambiguous: Each step of the algorithm must be clearly defined and easy to
understand.

Finite: An algorithm must have a finite number of steps and terminate after reaching the
solution.

Input and Output: Algorithms accept input, process it through the defined steps, and produce
output.

Effectiveness: Each step should be simple enough to be executed, ideally using basic
operations.

5.3 Examples of Algorithms

Cooking Recipe: A recipe can be viewed as an algorithm where the ingredients (inputs) are
combined in a specific order (steps) to produce a dish (output).

Sorting a List: An algorithm that sorts a list of numbers in ascending order can involve steps like
comparing numbers and swapping them until the list is sorted.

Activity Example:

Task: Ask students to write a simple algorithm for a daily activity, such as getting ready for
school or making a sandwich. They should outline the steps clearly.

---

Objective 6: Represent Algorithms in the Form of Flowcharts and Pseudocode

6.1 Flowcharts

A flowchart is a visual representation of an algorithm. It uses standardized symbols to denote

different types of actions or steps in a process.

Common Flowchart Symbols:

Oval: Start/End
Rectangle: Process/Instruction

Diamond: Decision (Yes/No)

Arrow: Flow of control

6.2 Example of a Flowchart

Consider an algorithm to determine if a number is odd or even:

1. Start

2. Input a number

3. If the number is divisible by 2, then it is even; otherwise, it is odd.

4. End

6.3 Pseudocode

Pseudocode is a high-level description of an algorithm that uses the structural conventions of

programming languages but is intended for human reading rather than machine reading. It
combines natural language with programming structure.

Example of Pseudocode

For the same algorithm that determines if a number is odd or even:

START
INPUT number
IF number MOD 2 = 0 THEN
PRINT "The number is even."
ELSE
PRINT "The number is odd."
ENDIF
END

Activity Example:

Task: Have students convert the algorithm for making a sandwich into both a flowchart and
pseudocode.

---

Objective 7: Test Algorithms for Correctness

7.1 Importance of Testing Algorithms

Testing an algorithm ensures that it produces the correct output for various inputs. This is critical
for verifying that the algorithm works as intended.

7.2 Testing Methods

1. Dry Run: Manually go through the algorithm using sample inputs to verify each step's output.

Example: Use the number 4 to see if the algorithm correctly identifies it as even.

2. Unit Testing: In programming, unit testing involves testing individual components of the code
to ensure they function correctly.

Example: Test the function that checks if a number is even separately from the rest of the
program.

3. Boundary Testing: Test edge cases, such as maximum and minimum values or zero.

Example: Check if the algorithm correctly identifies 0 as even and 1 as odd.

4. Performance Testing: Assess how the algorithm performs under heavy loads or with large
data sets to ensure it executes within acceptable time limits.
7.3 Example of Testing an Algorithm

For the even/odd checking algorithm:

Input Values: 2, 3, 0, -1

Expected Outputs: Even, Odd, Even, Odd

Dry Run Results: Confirm each output matches expectations.

Activity Example:

Task: Provide students with different test cases for the sandwich-making algorithm they created.
They should conduct a dry run and verify the correctness of each step.

---

Video Resources:

1. Understanding Algorithms:

What is an Algorithm?

2. Flowcharts Explained:

Flowcharts for Beginners

3. Pseudocode Tutorial:

Pseudocode Basics

4. Testing Algorithms:

How to Test Algorithms

---

This teaching content provides a comprehensive overview of algorithms, their representations

through flowcharts and pseudocode, and the importance of testing for correctness. Engaging
activities and video resources will help students grasp these concepts and apply them in
practical scenarios.