Computing · JC 2 · Computational Thinking Project · Semester 2

Building and Iterating a Project

Students will learn to build their project in small steps, testing and improving it along the way based on feedback.

• MOE Syllabus Outcomes
• MOE: Computational Thinking Project - Middle School

About This Topic

Building and Iterating a Project guides JC 2 students to construct computational solutions incrementally within the MOE Computational Thinking Project unit. They decompose tasks into small, testable components, prototype code or apps, run trials to identify flaws, collect peer and self-feedback, and refine iteratively. This method answers key questions on the benefits of step-by-step building and effective feedback use, directly supporting standards for middle school computational thinking extended to pre-university level.

Students connect this to real-world agile development, where professionals release minimum viable products and improve based on user input. Practicing iteration cultivates debugging skills, adaptability to failures, and version tracking, preparing them for H2 Computing syllabi and industry demands in Singapore's tech sector. Regular cycles prevent overwhelm from large-scale projects and promote a growth mindset.

Active learning excels for this topic because students engage in hands-on coding sprints and live feedback sessions. When they build a module, test it immediately with partners, and revise visibly, they internalize the efficiency of small steps. Collaborative critiques reveal blind spots, making the process dynamic and relevant to their project work.

Key Questions

1. Why is it helpful to build a project in small steps?
2. How can we get feedback to make our project better?
3. Demonstrate how you tested a part of your project and made improvements.

Learning Objectives

• Design a minimum viable product (MVP) for a given computational problem.
• Evaluate the effectiveness of code modules through targeted testing scenarios.
• Synthesize peer and self-feedback to refine project functionality and user experience.
• Demonstrate the iterative process of debugging and improving code based on test results.
• Critique the trade-offs between rapid prototyping and thorough initial design in project development.

Before You Start

Introduction to Programming Concepts

Why: Students need a foundational understanding of variables, data types, control flow (loops, conditionals), and functions to build and test code.

Problem Decomposition

Why: The ability to break down a complex problem into smaller, manageable parts is essential for building a project incrementally.

Key Vocabulary

Iteration	The process of repeating a set of instructions or steps, often with modifications, to achieve a desired outcome or improve a result.
Minimum Viable Product (MVP)	A version of a new product which allows a team to collect the maximum amount of validated learning about customers with the least effort.
Feedback Loop	A system where the output of a process is fed back as input, allowing for continuous improvement and adjustment.
Prototyping	The creation of an early model or sample of a product to test concepts, design, and user interaction before full development.
Debugging	The systematic process of finding and fixing errors, or 'bugs', in computer programs that prevent them from operating correctly.

Watch Out for These Misconceptions

Common Misconception

Projects work best when built completely before any testing.

What to Teach Instead

Early testing uncovers issues in isolated parts, preventing cascade failures. Pair testing activities let students compare full-build delays with quick fixes, building confidence in incremental approaches through shared timelines.

Common Misconception

Only teacher feedback counts for improvements.

What to Teach Instead

Peers offer diverse user perspectives that teachers might miss. Group feedback rounds expose students to varied critiques, helping them prioritize changes and value collaborative input over solo perfectionism.

Common Misconception

Iteration means restarting from scratch each time.

What to Teach Instead

True iteration refines existing work incrementally. Logging activities show students how small tweaks accumulate progress, with active peer reviews reinforcing targeted changes over wasteful overhauls.

Active Learning Ideas

Pair Prototyping: Core Function Cycle

Pairs code one project function, like user input validation, test it with sample data, and swap code with another pair for 2-minute feedback. They note issues and revise once before sharing improvements with the class. Emphasize logging changes in a shared document.

30 min·Pairs

Small Group Feedback Rounds: Prototype Review

Groups of four present a 5-minute prototype demo. Peers use a feedback template: two strengths, two suggestions, one question. Presenters iterate for 10 minutes and re-demo. Rotate roles to ensure everyone critiques and revises.

45 min·Small Groups

Individual Sprint Log: Test and Tweak

Students work solo on their project module for 10 minutes, run three tests, log bugs and fixes in a digital journal. Pair share logs for cross-checks, then apply one peer idea. Repeat for two cycles to build iteration habit.

25 min·Individual

Whole Class Iteration Showcase: Before-After

Two volunteers demo initial code flaws live. Class suggests tests; volunteer fixes on projector. Discuss time saved versus full rebuild. All students then apply one class tip to their work.

20 min·Whole Class

Real-World Connections

• Software engineers at Grab Singapore use agile methodologies, releasing app updates with new features incrementally and gathering user feedback to refine services like ride-hailing and food delivery.
• Game developers at Ubisoft Singapore build game levels and mechanics in stages, testing playability with internal teams and beta testers before a full product launch, incorporating feedback to enhance player experience.

Assessment Ideas

Quick Check

Present students with a short code snippet for a specific function (e.g., user login). Ask them to write 2-3 test cases that would verify its functionality and identify one potential edge case.

Peer Assessment

Students demonstrate a working module of their project to a small group. Group members use a simple rubric to assess: Does it meet the stated requirement? Is the code clear? What is one suggestion for improvement? The presenter notes down feedback.

Exit Ticket

Ask students to reflect on their last iteration cycle. Prompt: 'What was the most significant bug you fixed, and how did you find it?' and 'What is one piece of feedback you received that will change your next development step?'

Frequently Asked Questions

How do students build computing projects in small steps?

Break the project into modules like input handling, logic processing, and output display. Assign one module per sprint: code, test with edge cases, get quick feedback, refine. Use timers for 15-minute cycles to maintain pace. This decomposition aligns with MOE standards, reduces cognitive load, and mirrors professional dev practices, ensuring steady progress toward a functional whole. Track via shared repositories for visibility.

Why is feedback essential for project iteration in JC Computing?

Feedback identifies usability flaws and logic gaps early, guiding targeted fixes that save time. In the Computational Thinking Project, it teaches students to anticipate user needs and adapt. Peer sessions provide real-world input diversity, building communication skills. Without it, projects risk misalignment with goals; structured templates ensure actionable, constructive responses for effective iterations.

How can active learning support building and iterating projects?

Active strategies like pair prototyping and group feedback make iteration experiential. Students code live, test instantly, and revise with peers, grasping small-step value through immediate results. Whole-class demos visualize before-after gains, boosting engagement. These methods counter passivity, foster ownership, and align with MOE's student-centered computing pedagogy, leading to deeper skill retention and project success.

What tools help track iterations in student projects?

Simple digital logs in Google Docs or GitHub basics record tests, changes, and rationale. Timestamps show efficiency gains. Rubrics score iteration depth: number of cycles, feedback incorporated, improvements evidenced. Introduce during sprints; students reflect weekly on what worked. This builds accountability, supports MOE assessment, and prepares for portfolio reviews in computing courses.