🔍 Lesson 7.3: Debugging Strategies

# Running this broken code:
def calculate_average(numbers):
    total = sum(numbers)
    return total / len(numbers)

scores = []
avg = calculate_average(scores)

# Python's error message (read BOTTOM-UP!):
#
# Traceback (most recent call last):          ← Start of trace
#   File "grades.py", line 6, in <module>     ← WHERE (caller)
#     avg = calculate_average(scores)
#   File "grades.py", line 3, in calculate_average  ← WHERE (exact)
#     return total / len(numbers)              ← The line that failed
# ZeroDivisionError: division by zero          ← WHAT + WHY
#
# Reading strategy:
# 1. Start at the BOTTOM: ZeroDivisionError: division by zero
# 2. Look UP for YOUR code (skip library files)
# 3. Line 3: return total / len(numbers) — dividing by len([]) which is 0
# 4. Line 6 shows HOW we got there: empty list passed in

// Running this broken code:
function calculateAverage(numbers) {
    let total = numbers.reduce((sum, n) => sum + n);
    return total / numbers.length;
}

let scores = null;
let avg = calculateAverage(scores);

// JavaScript's error message:
//
// TypeError: Cannot read properties of null (reading 'reduce')
//     at calculateAverage (grades.js:2:28)    ← WHERE (exact)
//     at Object.<anonymous> (grades.js:7:11)  ← WHERE (caller)
//
// Reading strategy:
// 1. First line: TypeError — trying to use null as an object
// 2. "reading 'reduce'" — the .reduce() call failed
// 3. grades.js:2:28 — line 2, column 28
// 4. Ask: why is 'numbers' null? → line 7 passes null

// Node.js shows the code line too:
// grades.js:2
//     let total = numbers.reduce((sum, n) => sum + n);
//                         ^
// TypeError: Cannot read properties of null (reading 'reduce')

// Running this broken code:
static double CalculateAverage(int[] numbers)
{
    int total = numbers.Sum();
    return total / numbers.Length;
}

int[] scores = null;
double avg = CalculateAverage(scores);

// C#'s error message:
//
// Unhandled exception. System.NullReferenceException:
//   Object reference not set to an instance of an object.
//    at Program.CalculateAverage(Int32[] numbers)
//       in /app/Program.cs:line 4              ← WHERE (exact)
//    at Program.Main(String[] args)
//       in /app/Program.cs:line 9              ← WHERE (caller)
//
// Reading strategy:
// 1. Exception type: NullReferenceException
// 2. Line 4: numbers.Sum() — numbers is null
// 3. Line 9: passed null to the function
// 4. Fix: add a null check or initialize the array

# Bug: this function returns wrong results for some inputs
def find_longest_word(sentence):
    words = sentence.split()
    longest = ""

    for word in words:
        if len(word) > len(longest):
            longest = word

    return longest

# It works for "hello world" but fails for "hello, world!"
# Let's debug with prints:

def find_longest_word(sentence):
    words = sentence.split()
    print(f"DEBUG words: {words}")           # See what split() produces

    longest = ""
    for word in words:
        print(f"DEBUG checking '{word}' (len={len(word)}) vs '{longest}' (len={len(longest)})")
        if len(word) > len(longest):
            longest = word
            print(f"DEBUG   → new longest: '{longest}'")

    print(f"DEBUG result: '{longest}'")
    return longest

# Test it:
result = find_longest_word("I love programming!")
# DEBUG words: ['I', 'love', 'programming!']
# DEBUG checking 'I' (len=1) vs '' (len=0)
# DEBUG   → new longest: 'I'
# DEBUG checking 'love' (len=4) vs 'I' (len=1)
# DEBUG   → new longest: 'love'
# DEBUG checking 'programming!' (len=12) vs 'love' (len=4)
# DEBUG   → new longest: 'programming!'
# DEBUG result: 'programming!'
#
# AHA! 'programming!' includes the punctuation!
# Fix: strip punctuation from words before comparing

// Bug: discount calculation sometimes returns negative prices
function applyDiscount(price, discountPercent) {
    let discount = price * discountPercent;
    let finalPrice = price - discount;
    return finalPrice;
}

// applyDiscount(100, 20) should give 80 but gives -1900!
// Let's debug with console.log:

function applyDiscount(price, discountPercent) {
    console.log("DEBUG inputs:", { price, discountPercent });

    let discount = price * discountPercent;
    console.log("DEBUG discount amount:", discount);

    let finalPrice = price - discount;
    console.log("DEBUG final price:", finalPrice);

    return finalPrice;
}

applyDiscount(100, 20);
// DEBUG inputs: { price: 100, discountPercent: 20 }
// DEBUG discount amount: 2000        ← There it is!
// DEBUG final price: -1900
//
// AHA! discountPercent is 20, not 0.20
// Fix: divide by 100, or expect 0.20 as input

// Pro tip: console methods for better output
console.log("simple message");
console.warn("⚠️ warning");         // Yellow in browser
console.error("❌ error");           // Red in browser
console.table([{a: 1}, {a: 2}]);    // Formatted table
console.group("Section");           // Collapsible group
console.log("detail 1");
console.log("detail 2");
console.groupEnd();

// Bug: search always returns "not found" even for existing items
static int FindIndex(string[] items, string target)
{
    for (int i = 0; i < items.Length; i++)
    {
        if (items[i] == target)
            return i;
    }
    return -1;
}

string[] names = { "Alice", "Bob", "Charlie" };
int index = FindIndex(names, "bob");  // Returns -1, but Bob is there!

// Let's debug with Console.WriteLine:
static int FindIndex(string[] items, string target)
{
    Console.WriteLine($"DEBUG searching for: '{target}'");

    for (int i = 0; i < items.Length; i++)
    {
        Console.WriteLine($"DEBUG   [{i}] comparing '{items[i]}' == '{target}' → {items[i] == target}");
        if (items[i] == target)
            return i;
    }

    Console.WriteLine("DEBUG   not found!");
    return -1;
}

FindIndex(names, "bob");
// DEBUG searching for: 'bob'
// DEBUG   [0] comparing 'Alice' == 'bob' → False
// DEBUG   [1] comparing 'Bob' == 'bob' → False    ← AHA!
// DEBUG   [2] comparing 'Charlie' == 'bob' → False
// DEBUG   not found!
//
// 'Bob' != 'bob' — case-sensitive comparison!
// Fix: use StringComparison.OrdinalIgnoreCase

// C# also has Debug.WriteLine (only runs in Debug mode):
// System.Diagnostics.Debug.WriteLine("Debug only message");

# Method 1: Insert a breakpoint in your code
def process_order(items, tax_rate):
    subtotal = sum(item["price"] * item["qty"] for item in items)

    breakpoint()  # Program PAUSES here! (Python 3.7+)
    # Older Python: import pdb; pdb.set_trace()

    tax = subtotal * tax_rate
    total = subtotal + tax
    return total

# When the program pauses, you get a (Pdb) prompt:
#
# (Pdb) p subtotal          ← Print a variable
# 59.97
# (Pdb) p items             ← Print the list
# [{'name': 'Widget', 'price': 9.99, 'qty': 3}, ...]
# (Pdb) p tax_rate           ← Check the tax rate
# 0.08
# (Pdb) n                    ← Next line (step over)
# (Pdb) s                    ← Step into function call
# (Pdb) c                    ← Continue (run until next breakpoint)
# (Pdb) l                    ← List source code around current line
# (Pdb) q                    ← Quit debugger

# Method 2: Run with debugger from the start
# python -m pdb your_script.py

# Method 3: VS Code (recommended for beginners)
# 1. Click the line number gutter to set a breakpoint (red dot)
# 2. Press F5 (Run → Start Debugging)
# 3. Use the debug toolbar: Step Over (F10), Step Into (F11),
#    Continue (F5), Stop (Shift+F5)
# 4. Hover over variables to see their values
# 5. Use the Variables panel and Watch panel

// Method 1: Insert a breakpoint in your code
function processOrder(items, taxRate) {
    let subtotal = items.reduce((sum, item) =>
        sum + item.price * item.qty, 0);

    debugger;  // Browser DevTools PAUSE here!

    let tax = subtotal * taxRate;
    let total = subtotal + tax;
    return total;
}

// When paused in Chrome/Firefox DevTools:
//
// Sources tab → your code is highlighted at the debugger line
// Scope panel → shows all local variables and their values
// Console → you can type any expression to evaluate it
//
// Controls:
//   F10 / Step Over    → Execute current line, move to next
//   F11 / Step Into    → Jump into function call
//   Shift+F11 / Out   → Run until current function returns
//   F8 / Continue      → Run until next breakpoint
//
// Watch panel → add expressions to monitor (e.g., items.length)
// Call Stack → see how you got to this point

// Method 2: Set breakpoints in DevTools
// 1. Open DevTools (F12 or Ctrl+Shift+I)
// 2. Go to Sources tab
// 3. Click a line number to set a breakpoint
// 4. Reload the page — execution pauses at the breakpoint

// Method 3: Conditional breakpoints
// Right-click a line number → "Add conditional breakpoint"
// Example: total > 1000  (only pauses when total exceeds 1000)

// Method 1: Debugger.Break() in code
static decimal ProcessOrder(List<OrderItem> items, decimal taxRate)
{
    decimal subtotal = items.Sum(i => i.Price * i.Qty);

    System.Diagnostics.Debugger.Break();  // Pauses if debugger attached

    decimal tax = subtotal * taxRate;
    decimal total = subtotal + tax;
    return total;
}

// Method 2: VS Code / Visual Studio (recommended)
//
// 1. Click the line number gutter → red dot (breakpoint)
// 2. Press F5 → Start Debugging
// 3. When paused:
//    - Hover over any variable to see its value
//    - Variables panel shows all locals
//    - Watch panel for custom expressions
//    - Immediate Window to evaluate code on the fly
//
// Stepping:
//    F10 → Step Over (execute line, don't enter functions)
//    F11 → Step Into (enter function calls)
//    Shift+F11 → Step Out (run to end of current function)
//    F5 → Continue (run to next breakpoint)
//
// Pro features:
//    - Conditional breakpoints: right-click → Condition → total > 1000
//    - Hit count breakpoints: break after N hits
//    - Logpoints: print without pausing (like smart print debugging)

// Method 3: Logging with conditional compilation
#if DEBUG
    Console.WriteLine($"DEBUG subtotal: {subtotal}");
#endif
// This code ONLY runs in Debug builds, not Release builds

# This pipeline produces the wrong final result.
# Where does it go wrong?

def load_data():
    return [
        {"name": "Widget", "price": "9.99", "qty": "5"},
        {"name": "Gadget", "price": "24.99", "qty": "2"},
        {"name": "Gizmo", "price": "14.99", "qty": "3"},
    ]

def clean_data(raw):
    cleaned = []
    for item in raw:
        cleaned.append({
            "name": item["name"],
            "price": float(item["price"]),
            "qty": int(item["qty"]),
        })
    return cleaned

def calculate_totals(items):
    for item in items:
        item["total"] = item["price"] + item["qty"]  # Bug here!
    return items

def apply_tax(items, rate=0.08):
    for item in items:
        item["total"] = item["total"] * (1 + rate)
    return items

def generate_report(items):
    grand_total = sum(item["total"] for item in items)
    return f"Grand total: ${grand_total:.2f}"

# Pipeline
raw = load_data()
cleaned = clean_data(raw)

# --- STEP 1: Check the midpoint ---
print(f"CHECKPOINT after clean_data: {cleaned}")
# Looks good! Prices and quantities are correct numbers.

totals = calculate_totals(cleaned)

# --- STEP 2: Bug is in second half — check after calculate_totals ---
print(f"CHECKPOINT after calculate_totals: {totals}")
# [{'name': 'Widget', 'total': 14.99}, ...]
# WAIT — 9.99 + 5 = 14.99? That's price + qty, not price * qty!

# Found it! Line: item["total"] = item["price"] + item["qty"]
# Should be: item["total"] = item["price"] * item["qty"]

// Same pipeline concept in JS — binary search for the bug

function loadData() {
    return [
        { name: "Widget", price: "9.99", qty: "5" },
        { name: "Gadget", price: "24.99", qty: "2" },
        { name: "Gizmo", price: "14.99", qty: "3" },
    ];
}

function cleanData(raw) {
    return raw.map(item => ({
        name: item.name,
        price: parseFloat(item.price),
        qty: parseInt(item.qty),
    }));
}

function calculateTotals(items) {
    return items.map(item => ({
        ...item,
        total: item.price + item.qty,   // Bug: should be *
    }));
}

function applyTax(items, rate = 0.08) {
    return items.map(item => ({
        ...item,
        total: item.total * (1 + rate),
    }));
}

// Binary search: check the midpoint first
let raw = loadData();
let cleaned = cleanData(raw);
console.log("CHECKPOINT cleaned:", cleaned);  // Looks good ✅

let totals = calculateTotals(cleaned);
console.log("CHECKPOINT totals:", totals);    // Bug found! ❌
// total: 14.99 for Widget → price + qty, not price * qty

// Binary search debugging in C#
// Check data at the midpoint of your pipeline

var raw = LoadData();
var cleaned = CleanData(raw);

// CHECKPOINT 1: Is data correct here?
Console.WriteLine("CHECKPOINT cleaned:");
foreach (var item in cleaned)
    Console.WriteLine($"  {item.Name}: ${item.Price} x {item.Qty}");
// Looks correct ✅

var totals = CalculateTotals(cleaned);

// CHECKPOINT 2: Check after calculate
Console.WriteLine("CHECKPOINT totals:");
foreach (var item in totals)
    Console.WriteLine($"  {item.Name}: total=${item.Total}");
// Widget: total=$14.99 — that's price + qty, not price * qty! ❌

// Bug found in CalculateTotals!
// item.Total = item.Price + item.Qty;  // Wrong!
// item.Total = item.Price * item.Qty;  // Correct!

# 1. Off-by-one
for i in range(10):    # 0-9, not 1-10!
    print(i)

# 2. Mutable default argument (Python-specific trap!)
def add_item(item, items=[]):    # ❌ Shared across ALL calls!
    items.append(item)
    return items

print(add_item("a"))  # ['a']
print(add_item("b"))  # ['a', 'b'] — Wait, where did 'a' come from?!

# Fix:
def add_item(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items

# 3. String/number confusion
age = input("Your age: ")  # ALWAYS returns a string!
if age > 18:               # ❌ Comparing string to int!
    print("Adult")
# Fix: age = int(input("Your age: "))

// 1. Type coercion surprises
console.log("5" + 3);     // "53" (string concatenation!)
console.log("5" - 3);     // 2   (numeric subtraction)
console.log("5" == 5);    // true  (loose equality — coerces type)
console.log("5" === 5);   // false (strict equality — safe!)

// 2. this context
class Timer {
    constructor() { this.seconds = 0; }
    start() {
        setInterval(function() {
            this.seconds++;  // ❌ 'this' is NOT the Timer!
            console.log(this.seconds);  // NaN
        }, 1000);
    }
}
// Fix: use arrow function (inherits 'this')
// setInterval(() => { this.seconds++; }, 1000);

// 3. Equality gotchas
console.log([] == false);   // true  (wat?)
console.log(null == undefined);  // true
console.log(NaN == NaN);   // false (NaN is not equal to anything!)
// Fix: ALWAYS use === and !== in JavaScript

// 1. Integer division truncation
int a = 7, b = 2;
Console.WriteLine(a / b);       // 3 (not 3.5!)
Console.WriteLine(a / (double)b);  // 3.5 — cast to double first

// 2. String comparison (case sensitivity)
string name = "Alice";
if (name == "alice")  // False! Case-sensitive by default
    Console.WriteLine("Found");
// Fix:
if (name.Equals("alice", StringComparison.OrdinalIgnoreCase))
    Console.WriteLine("Found");

// 3. Reference equality vs value equality
int[] a1 = { 1, 2, 3 };
int[] a2 = { 1, 2, 3 };
Console.WriteLine(a1 == a2);             // False! Different objects
Console.WriteLine(a1.SequenceEqual(a2)); // True — compares contents

// 4. Null reference (the billion-dollar mistake)
string? text = null;
Console.WriteLine(text.Length);  // NullReferenceException!
// Fix:
Console.WriteLine(text?.Length ?? 0);  // 0 (null-safe)