Code with AI Lesson 4: Debugging with AI

# Code with error
numbers = [1, 2, 3, 4, 5]
result = sum(numbers, [])

# Error message
TypeError: unsupported operand type(s) for +: 'int' and 'list'

The error occurs because sum() is trying to add integers to a list.
The second parameter [] makes sum start with an empty list, 
then tries to add numbers to it. 

Fix: Remove the second parameter or use:
result = sum(numbers)  # For adding numbers
# OR
result = sum([numbers], [])  # For concatenating lists

// Code with error
function calculateTotal() {
    let subtotal = 100;
    let tax = subtotal * taxRate;
    return subtotal + tax;
}

// Error message
ReferenceError: taxRate is not defined

The variable 'taxRate' is used but never declared or defined.

Possible fixes:
1. Define taxRate as a parameter:
   function calculateTotal(taxRate) { ... }

2. Define taxRate as a constant:
   const taxRate = 0.08;

3. Pass it as a global variable:
   let taxRate = 0.08; // Outside function

Traceback (most recent call last):
  File "app.py", line 45, in process_data
    result = analyze_records(data)
  File "app.py", line 23, in analyze_records
    average = calculate_average(record['values'])
  File "app.py", line 12, in calculate_average
    return sum(numbers) / len(numbers)
ZeroDivisionError: division by zero

Error Flow:
1. process_data() called analyze_records() 
2. analyze_records() called calculate_average()
3. calculate_average() tried to divide by zero

Root cause: Empty list passed to calculate_average()

Fix in calculate_average():
def calculate_average(numbers):
    if not numbers:  # Check for empty list
        return 0  # or raise ValueError("Cannot calculate average of empty list")
    return sum(numbers) / len(numbers)

def find_user(users, target_id):
    for user in users:
        if user.id == target_id:
            return user
    return None

# Usage
result = find_user(user_list, "123")
print(result.name)  # AttributeError sometimes

"This function sometimes throws AttributeError when accessing result.name. 
It should find a user by ID and return the user object."

The AttributeError occurs when find_user returns None (user not found),
and you try to access .name on None.

Issues identified:
1. No null check before accessing .name
2. Potential type mismatch (string "123" vs integer id)
3. No validation of users list

Fixes:
1. Check if result is None before accessing properties
2. Ensure consistent ID types
3. Add input validation

def find_user(users, target_id):
    """Find a user by ID with proper error handling."""
    if not users:
        return None
    
    # Ensure consistent type comparison
    target_id = str(target_id)
    
    for user in users:
        if str(user.id) == target_id:
            return user
    return None

# Safe usage
result = find_user(user_list, "123")
if result:
    print(result.name)
else:
    print("User not found")

// Problematic code from production
class WebSocketManager {
    constructor() {
        this.connections = new Map();
        this.messageHandlers = [];
    }
    
    addConnection(userId, socket) {
        this.connections.set(userId, socket);
        
        // Bug: Event listeners not cleaned up
        socket.on('message', (data) => {
            this.messageHandlers.push({
                userId,
                data,
                timestamp: new Date()
            });
            this.processMessage(userId, data);
        });
    }
    
    removeConnection(userId) {
        this.connections.delete(userId);
        // Missing: Clean up event listeners and message history!
    }
}

class WebSocketManager {
    constructor() {
        this.connections = new Map();
        this.messageHandlers = new Map(); // Use Map for easier cleanup
        this.maxMessageHistory = 100; // Limit history size
    }
    
    addConnection(userId, socket) {
        // Store socket and handler reference
        const messageHandler = (data) => {
            this.addMessageToHistory(userId, data);
            this.processMessage(userId, data);
        };
        
        this.connections.set(userId, { socket, messageHandler });
        socket.on('message', messageHandler);
        
        // Set up automatic cleanup on disconnect
        socket.on('close', () => this.removeConnection(userId));
    }
    
    addMessageToHistory(userId, data) {
        if (!this.messageHandlers.has(userId)) {
            this.messageHandlers.set(userId, []);
        }
        
        const userMessages = this.messageHandlers.get(userId);
        userMessages.push({
            data,
            timestamp: new Date()
        });
        
        // Prevent unbounded growth
        if (userMessages.length > this.maxMessageHistory) {
            userMessages.shift(); // Remove oldest
        }
    }
    
    removeConnection(userId) {
        const connection = this.connections.get(userId);
        if (connection) {
            // Clean up event listeners
            connection.socket.removeListener('message', connection.messageHandler);
            connection.socket.removeAllListeners();
            
            // Clear connection data
            this.connections.delete(userId);
            this.messageHandlers.delete(userId);
        }
    }
}

def get_last_n_items(items, n):
    return items[len(items) - n + 1:]  # Off by one!

# Test
print(get_last_n_items([1, 2, 3, 4, 5], 2))  # Expected [4, 5], got [5]

def get_last_n_items(items, n):
    # Correct: No +1 needed
    return items[len(items) - n:]
    # Or simply: return items[-n:]
    
# Edge case handling
def get_last_n_items_safe(items, n):
    if n <= 0:
        return []
    if n > len(items):
        return items[:]
    return items[-n:]

def add_tax(prices, tax_rate):
    for i in range(len(prices)):
        prices[i] = prices[i] * (1 + tax_rate)  # Mutates original!
    return prices

original_prices = [10, 20, 30]
with_tax = add_tax(original_prices, 0.1)
print(original_prices)  # [11.0, 22.0, 33.0] - Original changed!

def add_tax(prices, tax_rate):
    # Create new list instead of mutating
    return [price * (1 + tax_rate) for price in prices]

# Or if you need to mutate, make it clear
def add_tax_in_place(prices, tax_rate):
    """Modifies prices list in place."""
    for i in range(len(prices)):
        prices[i] = prices[i] * (1 + tax_rate)
    # No return needed for in-place modification

async function fetchUserData(userId) {
    const response = fetch(`/api/users/${userId}`);  // Missing await!
    return response.json();  // This won't work
}

async function fetchUserData(userId) {
    try {
        const response = await fetch(`/api/users/${userId}`);
        if (!response.ok) {
            throw new Error(`HTTP error! status: ${response.status}`);
        }
        const data = await response.json();
        return data;
    } catch (error) {
        console.error('Error fetching user data:', error);
        throw error;  // Re-throw for caller to handle
    }
}

class AccountService {
    async transferMoney(fromId, toId, amount) {
        // Race condition: Multiple transfers can read same balance
        const fromAccount = await this.getAccount(fromId);
        const toAccount = await this.getAccount(toId);
        
        if (fromAccount.balance < amount) {
            throw new Error('Insufficient funds');
        }
        
        // Time gap where other operations can interfere
        fromAccount.balance -= amount;
        toAccount.balance += amount;
        
        await this.updateAccount(fromAccount);
        await this.updateAccount(toAccount);
    }
}

class AccountService {
    async transferMoney(fromId, toId, amount, retries = 3) {
        // Use database transaction with row locking
        const transaction = await this.db.transaction();
        
        try {
            // Lock accounts in consistent order to prevent deadlocks
            const [lockId1, lockId2] = [fromId, toId].sort();
            
            const accounts = await transaction
                .select('*')
                .from('accounts')
                .whereIn('id', [lockId1, lockId2])
                .forUpdate(); // Row-level locking
            
            const fromAccount = accounts.find(a => a.id === fromId);
            const toAccount = accounts.find(a => a.id === toId);
            
            if (!fromAccount || !toAccount) {
                throw new Error('Account not found');
            }
            
            if (fromAccount.balance < amount) {
                throw new Error('Insufficient funds');
            }
            
            // Atomic updates within transaction
            await transaction('accounts')
                .where('id', fromId)
                .update({ 
                    balance: fromAccount.balance - amount,
                    updated_at: new Date()
                });
                
            await transaction('accounts')
                .where('id', toId)
                .update({ 
                    balance: toAccount.balance + amount,
                    updated_at: new Date()
                });
            
            // Record transaction log
            await transaction('transaction_logs').insert({
                from_account_id: fromId,
                to_account_id: toId,
                amount: amount,
                timestamp: new Date(),
                status: 'completed'
            });
            
            await transaction.commit();
            
        } catch (error) {
            await transaction.rollback();
            
            // Retry on deadlock
            if (error.code === 'ER_LOCK_DEADLOCK' && retries > 0) {
                console.warn(`Deadlock detected, retrying... (${retries} attempts left)`);
                await new Promise(resolve => setTimeout(resolve, 100));
                return this.transferMoney(fromId, toId, amount, retries - 1);
            }
            
            throw error;
        }
    }
}

"I have a function that processes 1000 lines of data. It works for small 
inputs but fails on large ones. Help me create a binary search debugging 
approach to find where it fails."

def debug_with_binary_search(data, process_function):
    """Find the failing point using binary search."""
    left, right = 0, len(data)
    last_working = 0
    
    while left < right:
        mid = (left + right) // 2
        try:
            # Test with subset
            subset = data[:mid]
            process_function(subset)
            print(f"✓ Works with \{mid\} items")
            last_working = mid
            left = mid + 1
        except Exception as e:
            print(f"✗ Fails with \{mid\} items: \{e\}")
            right = mid
    
            print(f"Failure occurs at item \{last_working + 1\}")
    return last_working

"Add strategic logging to this function to help debug issues in production"

def process_order(order_data):
    validate_order(order_data)
    items = fetch_items(order_data['items'])
    total = calculate_total(items)
    apply_discounts(order_data, total)
    return create_invoice(order_data, total)

import logging
from functools import wraps
import time

logger = logging.getLogger(__name__)

def log_execution_time(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        start = time.time()
        try:
            result = func(*args, **kwargs)
            elapsed = time.time() - start
            logger.info(f"\{func.__name__\} completed in \{elapsed:.2f\}s")
            return result
        except Exception as e:
            elapsed = time.time() - start
            logger.error(f"\{func.__name__\} failed after \{elapsed:.2f\}s: \{e\}")
            raise
    return wrapper

@log_execution_time
def process_order(order_data):
    logger.info(f"Processing order: \{order_data.get('order_id', 'Unknown')\}")
    
    try:
        logger.debug(f"Validating order data: \{len(order_data)\} fields")
        validate_order(order_data)
        
        logger.debug(f"Fetching \{len(order_data['items'])\} items")
        items = fetch_items(order_data['items'])
        
        logger.debug(f"Calculating total for \{len(items)\} items")
        total = calculate_total(items)
        logger.info(f"Order total before discounts: $\{total\}")
        
        logger.debug("Applying discounts")
        final_total = apply_discounts(order_data, total)
        logger.info(f"Final total after discounts: $\{final_total\}")
        
        logger.debug("Creating invoice")
        invoice = create_invoice(order_data, final_total)
        logger.info(f"Order \{order_data['order_id']\} processed successfully")
        
        return invoice
        
    except Exception as e:
        logger.error(f"Order processing failed: \{e\}", exc_info=True)
        raise

class StateDebugger:
    """Track and visualize state changes during execution."""
    
    def __init__(self):
        self.states = []
        self.enabled = True
    
    def capture(self, label, **variables):
        """Capture current state of variables."""
        if not self.enabled:
            return
            
        state = {
            'label': label,
            'timestamp': time.time(),
            'variables': \{k: repr(v) for k, v in variables.items()\}
        }
        self.states.append(state)
    
    def print_trace(self):
        """Print the execution trace."""
        print("\n=== Execution Trace ===")
        for i, state in enumerate(self.states):
            print(f"\n[\{i\}] \{state['label']\}")
            for var, value in state['variables'].items():
                print(f"  \{var\}: \{value\}")
    
    def find_state_change(self, variable_name):
        """Find where a variable changed."""
        changes = []
        last_value = None
        
        for state in self.states:
            if variable_name in state['variables']:
                current_value = state['variables'][variable_name]
                if current_value != last_value:
                    changes.append({
                        'label': state['label'],
                        'old_value': last_value,
                        'new_value': current_value
                    })
                    last_value = current_value
        
        return changes

# Usage example
debugger = StateDebugger()

def complex_calculation(data):
    debugger.capture("Start", data=data)
    
    result = 0
    for i, item in enumerate(data):
        debugger.capture(f"Loop iteration \{i\}", i=i, item=item, result=result)
        result += item * 2
        
    debugger.capture("End", result=result)
    return result

Prompt: "This function is slow with large datasets. Help me identify 
and fix performance issues:

def find_duplicates(items):
    duplicates = []
    for i in range(len(items)):
        for j in range(i + 1, len(items)):
            if items[i] == items[j] and items[i] not in duplicates:
                duplicates.append(items[i])
    return duplicates
"

# Problem: O(n²) time complexity with nested loops

# Optimized version 1: Using set for O(n) average case
def find_duplicates_optimized(items):
    seen = set()
    duplicates = set()
    
    for item in items:
        if item in seen:
            duplicates.add(item)
        else:
            seen.add(item)
    
    return list(duplicates)

# Optimized version 2: Using Counter for frequency analysis
from collections import Counter

def find_duplicates_counter(items):
    counts = Counter(items)
    return [item for item, count in counts.items() if count > 1]

# Performance comparison
import time

def benchmark(func, data):
    start = time.time()
    result = func(data)
    elapsed = time.time() - start
    return elapsed, result

# Test with large dataset
test_data = list(range(1000)) * 2  # 2000 items with duplicates

for func in [find_duplicates, find_duplicates_optimized, find_duplicates_counter]:
    elapsed, result = benchmark(func, test_data)
    print(f"\{func.__name__\}: \{elapsed:.4f\} seconds")

"Help me identify potential memory leaks in this Python class"

# Potential memory leak
class DataProcessor:
    def __init__(self):
        self.cache = {}  # Unbounded cache!
    
    def process(self, data):
        key = str(data)
        if key not in self.cache:
            self.cache[key] = expensive_operation(data)
        return self.cache[key]

# Fixed version with bounded cache
from collections import OrderedDict

class DataProcessor:
    def __init__(self, max_cache_size=1000):
        self.cache = OrderedDict()
        self.max_cache_size = max_cache_size
    
    def process(self, data):
        key = str(data)
        
        if key in self.cache:
            # Move to end (most recently used)
            self.cache.move_to_end(key)
            return self.cache[key]
        
        # Calculate result
        result = expensive_operation(data)
        
        # Add to cache with size limit
        self.cache[key] = result
        if len(self.cache) > self.max_cache_size:
            # Remove least recently used
            self.cache.popitem(last=False)
        
        return result

Problem: [Brief description]

Minimal code to reproduce:
```python
# Smallest possible code that shows the bug

### Defensive Programming
Preventing bugs before they happen.

**AI-Suggested Defensive Patterns:**
__CODE_BLOCK_32__`

## Key Takeaways

### Summary of Learning

* AI can interpret complex error messages and stack traces
* Systematic debugging approaches improve efficiency
* Common bug patterns have standard solutions
* Performance debugging benefits from AI analysis
* Defensive programming prevents future bugs

### Debugging Skills Developed

* Reading and understanding error messages
* Using AI to analyze stack traces
* Implementing strategic logging
* Finding and fixing performance issues
* Creating minimal reproducible examples

### Next Steps

In the final lesson, you'll learn:

* Best practices for AI-assisted development
* Ethical considerations in AI coding
* Building sustainable coding habits
* Creating your own AI-enhanced workflow

**Remember:** AI is an excellent debugging assistant, but developing your debugging intuition through practice makes you a better programmer. Use AI to accelerate learning, not replace understanding!