Computer Science · Grade 11

Active learning ideas

Debugging Object-Oriented Programs

Active learning builds debugging intuition by forcing students to confront real runtime states, not just code syntax. Hands-on debugging demands they verbalize their assumptions and test them against actual behavior, which deepens understanding far more than passive reading or lectures.

• Ontario Curriculum Expectations
• CS.HS.P.5

• 30–45 min
• Pairs → Whole Class
• 4 activities

Activity 01

• Collaborative Problem-Solving
• 30 min · Pairs

Pair Debug: Bug Exchange

Students create a short OOP program with one intentional bug, such as a null reference or wrong method call. They exchange code with a partner, use the IDE debugger to set breakpoints and step through execution, then fix and explain the issue. Partners verify the fix runs correctly.

Analyze common types of errors encountered in OOP (e.g., null pointer exceptions, incorrect inheritance).

Facilitation Tip

During Pair Debug: Bug Exchange, insist students narrate each step out loud before they touch the keyboard, so partners can catch misconceptions early.

What to look for

Provide students with a small, buggy object-oriented code snippet (e.g., a simple class with a method that causes a NullPointerException). Ask them to identify the specific line causing the error and explain why it occurs, using one debugger concept (e.g., breakpoint, step-through).

• Apply
• Analyze
• Evaluate
• Create
• Relationship Skills
• Decision-Making
• Self-Management

Activity 02

• Collaborative Problem-Solving
• 45 min · Small Groups

Small Groups: Error Type Rotations

Prepare four stations, each with sample OOP code exhibiting a different error: null pointer, inheritance flaw, encapsulation breach, polymorphism issue. Groups rotate every 10 minutes, debug using tools, record steps, and propose fixes. Debrief as a class on patterns.

Explain how to effectively use a debugger to trace program execution and inspect object states.

Facilitation Tip

For Error Type Rotations, rotate code snippets every 8 minutes and require groups to leave a short note explaining the bug and the debugger feature that revealed it.

What to look for

Pose the scenario: 'You've inherited a project with a bug that only occurs intermittently. What are the first three systematic steps you would take to reproduce and isolate this bug?' Facilitate a class discussion comparing different approaches.

• Apply
• Analyze
• Evaluate
• Create
• Relationship Skills
• Decision-Making
• Self-Management

Activity 03

• Collaborative Problem-Solving
• 35 min · Whole Class

Whole Class: Live Trace Challenge

Project a complex OOP app with hidden bugs. Students follow on their machines as you set breakpoints and step through together, predicting states and suggesting fixes. Pause for think-pair-share on key inspection points before revealing resolutions.

Construct a systematic approach to debugging a complex object-oriented application.

Facilitation Tip

In the Live Trace Challenge, ask volunteers to predict variable states at each breakpoint before you resume execution, forcing transparent reasoning.

What to look for

Ask students to write down one common OOP error they learned about today and describe one specific debugger feature they would use to investigate it. They should also briefly explain how that feature helps.

• Apply
• Analyze
• Evaluate
• Create
• Relationship Skills
• Decision-Making
• Self-Management

Activity 04

• Collaborative Problem-Solving
• 40 min · Individual

Individual: Timed Bug Hunt

Provide a multi-class OOP project with 5 embedded bugs. Students use debugger systematically: reproduce, isolate, fix, test. Submit logs of breakpoints and changes. Review top strategies in follow-up discussion.

Analyze common types of errors encountered in OOP (e.g., null pointer exceptions, incorrect inheritance).

Facilitation Tip

Set a strict 5-minute timer for the Timed Bug Hunt and have students submit their fix plus the debugger feature that saved them time.

What to look for

Provide students with a small, buggy object-oriented code snippet (e.g., a simple class with a method that causes a NullPointerException). Ask them to identify the specific line causing the error and explain why it occurs, using one debugger concept (e.g., breakpoint, step-through).

• Apply
• Analyze
• Evaluate
• Create
• Relationship Skills
• Decision-Making
• Self-Management

A few notes on teaching this unit

Start with a mini-lesson that contrasts syntax errors with runtime OOP bugs, using a deliberately broken inheritance chain as the example. Avoid live-coding; instead, show the trace step-by-step so students see how object states change across method calls. Research shows pairing novices with more experienced debuggers accelerates skill transfer, so rotate partners often.

Students will confidently reproduce bugs, trace object states across class boundaries, and apply debugger tools without being prompted. They should explain their fix in terms of object lifecycles and inheritance flows rather than just ‘the code was wrong.’

---

Watch Out for These Misconceptions

• During Pair Debug: Bug Exchange, watch for students who immediately edit the code without reproducing the error or using the debugger to isolate the null pointer.

  Pause the pair and ask them to set a breakpoint at the suspected line, step through until the object reference shows as null, then explain why that state occurred before they change anything.

• During Error Type Rotations, watch for groups that use print statements to debug inheritance or polymorphism issues.

  Redirect them to the object inspector to view the actual class hierarchy at runtime, then have them compare the printed output to the live object graph.

• During Live Trace Challenge, watch for students who assume a bug is confined to one class without tracing object references.

  Ask the class to vote on the next breakpoint location, forcing them to consider how objects flow between classes before resuming execution.

---

Methods used in this brief

• Collaborative Problem-Solving