Error Handling and Exceptions

Active learning works for error handling because students need to experience the disruptive nature of exceptions firsthand. When they see a crash caused by their own code, they better understand why handling errors is essential for reliability and user trust.

• 11th Grade
• Computer Science
• 3 activities
• 25 min–40 min

Learning Objectives

1. Identify and classify common runtime errors in a given Java or Python program.
2. Analyze the potential consequences of unhandled exceptions on software reliability and user experience.
3. Design and implement appropriate try-catch or try-except blocks to handle specific exceptions in a program.
4. Evaluate the effectiveness of different exception handling strategies in preventing program crashes.
5. Create a program that demonstrates robust error handling for invalid user input and potential file access issues.

Problem-Based Learning

⏱ 35 min·Pairs

Debug It: Find and Fix the Exception

Provide five short code samples, each with a different unhandled runtime exception (NullPointerException, ArrayIndexOutOfBoundsException, NumberFormatException, FileNotFoundException, StackOverflowError). Students individually identify the exception type, explain what triggers it, and add appropriate error handling. Pairs compare their solutions and discuss differences in approach.

Prepare & details

Explain the importance of error handling in creating reliable software.

Facilitation Tip: During Debug It, have students work in pairs to trace the stack trace line by line before writing any fixes.

Setup: Groups at tables with access to research materials

Materials: Problem scenario document, KWL chart or inquiry framework, Resource library, Solution presentation template

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

Problem-Based Learning

⏱ 40 min·Small Groups

Design Challenge: Crash-Proof the Calculator

Groups receive a simple command-line calculator that crashes on invalid input, division by zero, and non-numeric entries. Their task is to add complete error handling that gives users informative messages and allows the program to continue running. Groups then exchange code and test each other's implementations by attempting to crash them.

Prepare & details

Analyze different types of errors (compile-time, runtime, logical) and how to address them.

Facilitation Tip: During Design Challenge, require students to create user-friendly error messages, not just silent catches.

Setup: Groups at tables with access to research materials

Materials: Problem scenario document, KWL chart or inquiry framework, Resource library, Solution presentation template

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

Gallery Walk

⏱ 25 min·Small Groups

Gallery Walk: Error Type Classification

Post six code snippets around the room, each with a specific error type (compile-time, runtime, or logical). Students rotate, classify each error type, and write what information would help diagnose and fix the problem. Debrief on the logical errors--which are hardest to detect and why.

Prepare & details

Design a strategy for handling exceptions in a given program to prevent crashes.

Facilitation Tip: During Gallery Walk, ask students to classify exceptions by their source (input, logic, I/O) as well as their type.

Setup: Wall space or tables arranged around room perimeter

Materials: Large paper/poster boards, Markers, Sticky notes for feedback

• Understand
• Apply
• Analyze
• Create
• Relationship Skills
• Social Awareness

Teaching This Topic

Teach error handling by starting with real failures—show students a program crash and ask them to diagnose it. Avoid beginning with syntax rules; instead, focus on the mindset of anticipating failure. Research shows that students grasp exception handling better when they see it as a communication tool between parts of a program rather than just a technical fix.

What to Expect

Successful learning looks like students confidently identifying exceptions, writing targeted handlers, and explaining why specific error types require specific responses. They should also articulate the risks of broad exception handling, demonstrating a shift from defensive to deliberate programming.

Watch Out for These Misconceptions

Common Misconception

During Design Challenge: Crash-Proof the Calculator, watch for students using a single broad catch block to handle all exceptions in their calculator code.

What to Teach Instead

Redirect students to the Calculator Design Spec sheet that explicitly asks them to handle at least three specific exceptions (e.g., division by zero, invalid input types, empty memory). Encourage them to document why each exception needs its own handler.

Common Misconception

During Debug It: Find and Fix the Exception, watch for students assuming that catching an exception means the program runs without issues afterward.

What to Teach Instead

Have students run the corrected code to verify the program still fails in a different way. Use the debrief to discuss how exception handling prevents crashes but does not fix the root cause of the error.

Common Misconception

During Gallery Walk: Error Type Classification, watch for students grouping exceptions only by their names (e.g., ValueError, FileNotFoundError) without considering their source.

What to Teach Instead

Provide the Error Type Classification worksheet with a column for source categories (user input, file operations, logic errors). Ask students to relabel their groups based on these categories during the walk.

Assessment Ideas

Quick Check

After Debug It: Find and Fix the Exception, collect students’ corrected code snippets and their written explanations of why each exception required a specific handler. Assess for accuracy in both identification and targeted response.

Discussion Prompt

During Design Challenge: Crash-Proof the Calculator, facilitate a whole-group discussion where students present their error-handling strategies. Listen for evidence that they considered user experience and specific exception types rather than generic catches.

Exit Ticket

After Gallery Walk: Error Type Classification, have students complete a short reflection: 'Choose one exception from today’s gallery. Describe its source, why it matters for program reliability, and how your group classified it. Include one improvement to the error message for that exception.'

Extensions & Scaffolding

• Challenge students to design a custom exception class for a calculator app that tracks repeated invalid operations.
• Scaffolding: Provide a partially completed try-except block with placeholders for the error type and handling logic.
• Deeper exploration: Compare languages by rewriting the same error-handling scenario in Python, Java, and JavaScript, noting differences in syntax and behavior.

Key Vocabulary

Exception	An event that occurs during program execution that disrupts the normal flow of instructions. Exceptions are used to signal and handle errors.
Try-Catch Block	A control structure in Java used to handle exceptions. Code that might cause an exception is placed in the 'try' block, and the 'catch' block specifies how to respond if an exception occurs.
Try-Except Block	A control structure in Python used to handle exceptions. Code that might cause an exception is placed in the 'try' block, and the 'except' block specifies how to respond if an exception occurs.
Runtime Error	An error that occurs while the program is executing, often due to unexpected conditions like invalid input or resource unavailability. These are also known as exceptions.
Unhandled Exception	An exception that is not caught by a try-catch or try-except block. If an unhandled exception occurs, the program typically terminates abruptly.