Week 12 — Discussion (Adaptive Learning) · "Fail Loudly or Fail Silently?"

Course: Introduction to Computer Science — CS1 / Programming Fundamentals in Python (CSCI 1101) · Silver Oak University (fictional sample) · Prof. Okafor
Objective: Objective 7 (exceptions; program design) · SLO B (reason about how code behaves under failure)
This is Discussion 12 of 15 · Discussions group = 10% of the grade · Worth 20 points
Format: adaptive learning — you think it through in a real-time dialogue with your own AI, then post the short summary it writes with you (plus your chat link).

Part 1 — Student Instructions (read this first)

What this is. A genuine design debate every programmer faces: when something goes wrong, should your program crash loudly with a clear error, or catch the exception and keep going quietly? You'll reason it out with an AI chatbot that challenges your thinking — it won't write your post for you — then post the summary it produces with you.

How to run it (about 15–20 minutes): (1) open an approved chatbot — Gemini, Claude, or ChatGPT; (2) copy everything in the box below as one message; (3) have the conversation and push back.

What to submit. Post the DISCUSSION SUMMARY + your chat share link to the Week 12 board as your initial post by Friday, Nov 20, then reply to two classmates by Sunday, Nov 22.

Integrity note. The reasoning is yours; the posted summary reflects your thinking. (Adaptive-learning activity — completed with an approved chatbot per the course AI policy.)

Part 2 — The Discussion-Partner Prompt (copy everything in the box)

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯ COPY EVERYTHING BELOW THIS LINE ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯

You are my discussion partner for Week 12 of Introduction to Computer Science (CSCI 1101) at Silver Oak University. We're debating a real software-design question: when an error happens, should a program fail LOUDLY (crash with a clear error) or fail SILENTLY (catch the exception and keep going)? Draw out and challenge MY thinking through conversation — don't lecture, and never write my post for me.

THE QUESTION & THE CASES
- Fail loudly: let the exception crash the program (or re-raise it) with a clear message — the bug is visible and gets fixed.
- Fail silently: wrap it in try/except (sometimes a bare except: pass) so the program keeps running — but a real bug might be hidden.
- Concrete cases to reason about: (a) a bare except: pass around a calculation that quietly produces wrong numbers; (b) a long overnight data job that crashes on ONE bad row vs. skips it and logs it; (c) a banking app that silently swallows a failed transfer; (d) reading a user's optional settings file that might not exist.

WHAT TO EXPLORE (private — don't read as a checklist): when hiding an error causes MORE harm than a crash (silent wrong answers, lost data, security); when catching-and-continuing is clearly right (an optional/missing file, one bad row out of millions); the middle path (catch a SPECIFIC exception, handle it meaningfully, and log it — rather than a bare except); and that "fail loudly" and "fail silently" each have a real place — the skill is choosing per situation.

HOW TO RUN THE DIALOGUE
- Greet me warmly (2–3 sentences), ask my FIRST NAME, and ask ONE question that gets me to take a first position. (If I never give my name, ask before the summary.)
- Exactly ONE question per message, then stop. Build on MY words. Make me apply my rule to at least two of the concrete cases above — and show me a case where my rule gives the WRONG call, so I refine it.
- Introduce a counterpoint (e.g., "but if it never crashes, users are happy, right?") so I defend or revise — and present the trade-off fairly, not as if one side is obviously correct.
- Keep YOUR messages short; I do most of the thinking. Don't accept one-word answers — probe for the reasoning. Don't hand me my post.

EXIT CONDITION. After at least 5 substantive exchanges AND once I have (a) stated a position with a reason, (b) applied it to at least two concrete cases, (c) acknowledged the specific-except-and-log middle path, and (d) engaged a counterpoint — tell me we've had a good discussion and summarize.

THE DISCUSSION SUMMARY — EXACTLY this format, drawn ONLY from what I said:
WEEK 12 DISCUSSION SUMMARY — Fail Loudly or Fail Silently?
Student: [name] | Date: ___
My position (and when it applies): ___
A case where failing silently is dangerous: ___
A case where catching-and-continuing is right: ___
The middle path / a counterpoint I weighed: ___
Then say, verbatim: "Copy this summary AND your share link to this chat, and post both to the Week 12 discussion board as your initial post — then reply to two classmates." End with one genuine sentence about something I reasoned well.

GETTING STARTED. Begin now: greet me, ask my first name, and ask your opening question.

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯ COPY EVERYTHING ABOVE THIS LINE ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯

Participation rubric (instructor) — 20 points

Grading note (Prof. Okafor): the posted artifact is the AI summary + chat link; spot-check links. A glowing summary from a one-line chat is the failure mode — the rubric rewards the dialogue.

Canvas placement block

canvas_object    = DiscussionTopic
title            = "Week 12 Discussion — Fail Loudly or Fail Silently? (adaptive)"
assignment_group = "Discussions"
points_possible  = 20
grading_type     = points
discussion_type  = adaptive
due_offset_days  = 4
reply_offset_days = 6
published        = true
submission_note  = "Initial post = the AI discussion summary + the chat share link; then reply to two classmates."
provenance       = "~ Prof. Okafor's edition · Fall 2026 · built with thecoursemaker.com"

Traditional variant — for comparison. This sample course is configured adaptive learning, so its actual Week-12 discussion is the BYOAI-dialogue version in G-discussion-week-12.md. This file shows the same topic built the traditional way — an instructor-posted prompt where students write their own post and reply to peers. (Choosing discussion_type = traditional at setup generates this style.)

Course: Introduction to Computer Science — CS1 / Programming Fundamentals in Python (CSCI 1101) · Silver Oak University (fictional sample) · Prof. Okafor
Objective: Objective 7 (exceptions; program design) · SLO B
Discussion 12 of 15 · Discussions group = 10% of the grade · Worth 20 points

The Discussion

This week you learned to catch errors with try / except. But should you always catch them? That's a real design question programmers argue about: when something goes wrong, should a program fail loudly (crash with a clear error so the bug is visible and gets fixed) or fail silently (catch the exception and keep running)?

Your initial post (by Friday, Nov 20 — about 150–200 words). Take a position and defend it with at least two of these concrete cases:
- A bare except: pass around a calculation that quietly produces wrong numbers.
- A long overnight data job that hits one bad row out of millions — crash, or skip-and-log?
- A banking app that silently swallows a failed money transfer.
- Reading a user's optional settings file that might not exist.

Then address the middle path: catching a specific exception, handling it meaningfully, and logging it — rather than a bare except that hides everything. When is loud right? When is quiet right?

Replies (by Sunday, Nov 22). Reply to at least two classmates: give a case where their rule makes the wrong call, or improve their middle-path proposal. One or two solid sentences each.

What a strong post looks like: "Default to failing loudly: a bare except: pass around a calculation is dangerous because the program keeps producing wrong numbers no one notices — and in the banking case, silently swallowing a failed transfer could lose someone's money. But for an optional settings file that might not exist, catching FileNotFoundError and using defaults is exactly right. My rule: catch a specific exception only when you can handle it meaningfully, and log it so it's never truly silent."

Why this matters: real software constantly chooses between these. The difference between a robust program and one that hides its own bugs is often a single try/except written thoughtfully — or carelessly.

Integrity & AI note. Write your post in your own words. You may use an approved chatbot to brainstorm or check an idea, but the post must be your own thinking; if AI helped, add a one-line note. (This is the traditional format; the adaptive version has you reason it out with the chatbot — see G-discussion-week-12.md.)

Participation rubric — 20 points

Grading note (Prof. Okafor): you read and grade each student's writing + two replies against this rubric — the traditional flow. (The adaptive version has students submit an AI-dialogue summary + chat link.)

Canvas placement block

canvas_object    = DiscussionTopic
title            = "Week 12 Discussion — Fail Loudly or Fail Silently? (traditional)"
assignment_group = "Discussions"
points_possible  = 20
grading_type     = points
discussion_type  = traditional
due_offset_days  = 4
reply_offset_days = 6
published        = true
submission_note  = "Students write an original initial post and reply to two classmates in the Canvas discussion."
provenance       = "~ Prof. Okafor's edition · Fall 2026 · built with thecoursemaker.com"