Introduction to Computational Thinking

Active learning works here because decomposition and modular design are skills best developed through doing. Students need to physically break down problems, see the value of reusable parts, and experience the frustration of tangled code to truly understand modularity.

• Year 9
• Technologies
• 3 activities
• 20 min–60 min

Learning Objectives

1. Analyze how decomposition simplifies complex problems into manageable parts for algorithm design.
2. Compare and contrast the roles of pattern recognition and abstraction in developing efficient algorithms.
3. Design a modular solution for a given problem by applying decomposition and abstraction principles.
4. Explain the relationship between algorithmic logic and modular code structure.

Inquiry Circle

⏱ 45 min·Small Groups

Inquiry Circle: The Recipe Swap

In small groups, students take a complex task like 'making a three-course meal' and decompose it into individual steps. They identify which steps are repeated (like 'boiling water' or 'chopping') and write these as 'functions' on index cards to be shared with other groups. This helps them see how modular components can be reused across different main programs.

Prepare & details

Analyze how computational thinking principles apply to everyday problem-solving.

Facilitation Tip: During Collaborative Investigation: The Recipe Swap, circulate to ensure groups are assigning discrete steps to functions rather than leaving them as sequential blocks in the main list.

Setup: Groups at tables with access to source materials

Materials: Source material collection, Inquiry cycle worksheet, Question generation protocol, Findings presentation template

• Analyze
• Evaluate
• Create
• Self-Management
• Self-Awareness

Think-Pair-Share

⏱ 20 min·Pairs

Think-Pair-Share: Library vs. Custom

Students are given a scenario, such as building a weather app, and must decide whether to write a custom sorting algorithm or use a pre-existing library. They discuss the trade-offs in pairs, focusing on time, reliability, and learning value, before sharing their reasoning with the class.

Prepare & details

Differentiate between decomposition and abstraction in problem-solving contexts.

Facilitation Tip: During Think-Pair-Share: Library vs. Custom, prompt students to contrast built-in functions with their own by asking them to explain which parts of a program feel more like a 'toolkit' and why.

Setup: Standard classroom seating; students turn to a neighbor

Materials: Discussion prompt (projected or printed), Optional: recording sheet for pairs

• Understand
• Apply
• Analyze
• Self-Awareness
• Relationship Skills

Stations Rotation

⏱ 60 min·Small Groups

Stations Rotation: Module Debugging

Set up stations with broken code modules that perform specific tasks like calculating GST or validating an email. Students rotate through stations to fix the individual module without seeing the rest of the program, reinforcing the idea that a well-designed module should work independently.

Prepare & details

Explain how pattern recognition aids in developing efficient algorithms.

Facilitation Tip: During Station Rotation: Module Debugging, provide a checklist at each station that reminds students to first identify the function’s purpose before fixing its logic.

Setup: Tables/desks arranged in 4-6 distinct stations around room

Materials: Station instruction cards, Different materials per station, Rotation timer

• Remember
• Understand
• Apply
• Analyze
• Self-Management
• Relationship Skills

Teaching This Topic

Teach this topic by modeling the process yourself in front of students. Start by solving a problem aloud while breaking it into steps, then refactor your code into functions without student input. This ‘think-aloud’ helps students see the decision-making behind decomposition. Avoid assigning large problems too early; scaffold with smaller, relatable tasks first. Research shows that students grasp modularity faster when they experience the pain of unorganized code before seeing the benefits of structured design.

What to Expect

Students will demonstrate the ability to decompose a problem, recognize patterns across tasks, and use functions to create organized, readable code. They will also explain why modular design improves collaboration and maintenance.

Watch Out for These Misconceptions

Common Misconception

During Collaborative Investigation: The Recipe Swap, watch for students who create functions only for repeated steps or who name functions vaguely like 'step1' or 'thing'.

What to Teach Instead

Use the group debrief to highlight a function named 'measureIngredients' versus 'step1'—ask students which name makes the program’s purpose clear at a glance. Have groups revise their functions to use descriptive names that explain the task's role in the whole recipe.

Common Misconception

During Think-Pair-Share: Library vs. Custom, watch for students who assume custom functions are only for advanced programmers.

What to Teach Instead

Ask students to compare the ease of using a built-in function like 'print()' with their own 'greetUser()'. Guide them to see that custom functions are tools they can create to tame complexity, just like library functions do.

Assessment Ideas

Quick Check

After Collaborative Investigation: The Recipe Swap, collect each group’s final recipe program and their list of decomposed functions. Assess whether functions are discrete, reusable, and named to reflect their purpose.

Discussion Prompt

During Think-Pair-Share: Library vs. Custom, listen for students to explain how abstraction simplifies user interaction in their language-learning app examples. Note whether they identify reducing steps, hiding complexity, or reusing modules as key benefits.

Exit Ticket

After Station Rotation: Module Debugging, have students submit their corrected modular code along with a one-sentence rationale for why their fix improves the program’s structure compared to the original.

Extensions & Scaffolding

• Challenge students finishing early by asking them to refactor a peer’s messy code into a modular version, then compare their solutions in a gallery walk.
• Scaffolding for struggling students: Provide partially decomposed problems with some steps already turned into function stubs to reduce cognitive load.
• Deeper exploration: Invite students to research how professional teams use modular design in open-source projects, then present one clear example to the class.

Key Vocabulary

Decomposition	Breaking down a complex problem or system into smaller, more manageable, and understandable parts.
Pattern Recognition	Identifying similarities, trends, or regularities within data or problems that can be used to make predictions or simplify solutions.
Abstraction	Focusing on essential features of a problem or system while ignoring irrelevant details to create a generalized solution.
Algorithm	A step-by-step set of instructions or rules designed to perform a specific task or solve a particular problem.
Modularity	Designing a system or program as a collection of independent, interchangeable components or modules.