Part 3: Runtime and Arithmetic Errors

Introduction

At 2 AM, I received an alert: my application had crashed. The logs showed ZeroDivisionError: division by zero. The code had been running fine for weeks, but a user had entered unexpected data, and suddenly everything stopped. This was my crash course in runtime errors—bugs that only appear when code is actually running, often with specific inputs or conditions.

Runtime and arithmetic errors are particularly challenging because they can hide during development and testing, only to emerge in production with real-world data.

Runtime Errors

What Are Runtime Errors?

Runtime errors occur during program execution when something unexpected happens that the code can't handle. Unlike syntax errors caught before execution, runtime errors only manifest when specific code paths are executed with particular data.

Real-World Examples from My Projects

Division by Zero

From a reporting dashboard I built:

# Incorrect - No handling for zero division
def calculate_success_rate(successful_requests, total_requests):
    """Calculate request success rate as percentage"""
    success_rate = (successful_requests / total_requests) * 100
    return success_rate

# Crashes when no requests made
rate = calculate_success_rate(0, 0)  # ZeroDivisionError!

Error:

ZeroDivisionError: division by zero

Correct version:

def calculate_success_rate(successful_requests, total_requests):
    """
    Calculate request success rate as percentage.
    
    Returns 0.0 if no requests were made.
    """
    if total_requests == 0:
        return 0.0
    
    success_rate = (successful_requests / total_requests) * 100
    return success_rate

# Better: With validation
def calculate_success_rate(successful_requests, total_requests):
    """Calculate request success rate as percentage"""
    if total_requests == 0:
        logger.warning("No requests to calculate success rate")
        return 0.0
    
    if successful_requests > total_requests:
        raise ValueError("Successful requests cannot exceed total requests")
    
    return (successful_requests / total_requests) * 100

Type Errors with User Input

From a CLI tool I developed:

# Incorrect - Assuming input is always a number
def set_timeout(timeout_value):
    """Set connection timeout in seconds"""
    # Bug: What if timeout_value is a string?
    timeout_seconds = timeout_value * 1000  # Convert to milliseconds
    configure_timeout(timeout_seconds)

# User passes "30" as string from command line
set_timeout("30")  # TypeError: can't multiply sequence by non-int

Correct version:

def set_timeout(timeout_value):
    """
    Set connection timeout in seconds.
    
    Args:
        timeout_value: Timeout in seconds (int, float, or string)
    
    Raises:
        ValueError: If timeout_value cannot be converted to number
        ValueError: If timeout is negative
    """
    try:
        timeout = float(timeout_value)
    except (ValueError, TypeError) as e:
        raise ValueError(f"Invalid timeout value: {timeout_value}") from e
    
    if timeout < 0:
        raise ValueError("Timeout cannot be negative")
    
    timeout_ms = int(timeout * 1000)
    configure_timeout(timeout_ms)
    return timeout_ms

# Better: With default fallback
def set_timeout(timeout_value, default=30):
    """Set connection timeout with safe fallback"""
    try:
        timeout = float(timeout_value)
        if timeout < 0:
            logger.warning(f"Negative timeout {timeout}, using default {default}")
            timeout = default
    except (ValueError, TypeError):
        logger.warning(f"Invalid timeout '{timeout_value}', using default {default}")
        timeout = default
    
    timeout_ms = int(timeout * 1000)
    configure_timeout(timeout_ms)
    return timeout_ms

Index Out of Range

From a log parser:

# Incorrect - Assuming list always has enough items
def parse_log_line(line):
    """Parse Apache log line format"""
    parts = line.split(' ')
    
    # Bug: What if log line is malformed?
    ip_address = parts[0]
    timestamp = parts[3]      # IndexError if parts < 4
    request = parts[6]        # IndexError if parts < 7
    status_code = parts[8]    # IndexError if parts < 9
    
    return {
        'ip': ip_address,
        'timestamp': timestamp,
        'request': request,
        'status': status_code
    }

# Malformed line with only 2 parts
parse_log_line("192.168.1.1 -")  # IndexError: list index out of range

Correct version:

def parse_log_line(line):
    """
    Parse Apache log line format.
    
    Returns None if line is malformed.
    """
    parts = line.split(' ')
    
    # Validate we have enough parts
    if len(parts) < 9:
        logger.warning(f"Malformed log line: {line}")
        return None
    
    try:
        return {
            'ip': parts[0],
            'timestamp': parts[3].strip('[]'),
            'request': parts[6],
            'status': int(parts[8])
        }
    except (IndexError, ValueError) as e:
        logger.error(f"Error parsing log line: {line}, error: {e}")
        return None

# Better: Using regex for robust parsing
import re

def parse_log_line(line):
    """Parse Apache log line using regex"""
    pattern = r'(\S+) \S+ \S+ \[([^\]]+)\] "(\S+) ([^\s]+) \S+" (\d+)'
    match = re.match(pattern, line)
    
    if not match:
        logger.warning(f"Could not parse log line: {line}")
        return None
    
    return {
        'ip': match.group(1),
        'timestamp': match.group(2),
        'method': match.group(3),
        'path': match.group(4),
        'status': int(match.group(5))
    }

Key Errors with Dictionaries

From a REST API client:

# Incorrect - Assuming response always has expected keys
def get_user_email(user_id):
    """Fetch user email from API"""
    response = api.get_user(user_id)
    
    # Bug: What if API response format changes?
    email = response['data']['user']['email']  # Nested KeyError risk
    return email

# API returns error response
# {'error': 'User not found'}
# KeyError: 'data'

Correct version:

def get_user_email(user_id):
    """
    Fetch user email from API.
    
    Returns None if user not found or email unavailable.
    """
    try:
        response = api.get_user(user_id)
        
        # Check for error response
        if 'error' in response:
            logger.error(f"API error for user {user_id}: {response['error']}")
            return None
        
        # Safely navigate nested structure
        email = response.get('data', {}).get('user', {}).get('email')
        
        if not email:
            logger.warning(f"No email found for user {user_id}")
            return None
        
        return email
    
    except Exception as e:
        logger.error(f"Failed to fetch email for user {user_id}: {e}")
        return None

# Better: Using dict.get() with defaults
def get_user_email(user_id):
    """Fetch user email from API with safe access"""
    response = api.get_user(user_id)
    
    # Check for API error
    if 'error' in response:
        raise APIError(f"User {user_id} not found: {response['error']}")
    
    # Safe nested access
    user_data = response.get('data', {})
    user = user_data.get('user', {})
    email = user.get('email')
    
    if not email:
        raise ValueError(f"User {user_id} has no email address")
    
    return email

File Not Found Errors

From a configuration loader:

# Incorrect - No handling for missing files
def load_config(config_path):
    """Load configuration from file"""
    with open(config_path, 'r') as f:
        config = json.load(f)
    return config

# File doesn't exist
config = load_config('/etc/myapp/config.json')  # FileNotFoundError

Correct version:

import os
import json

def load_config(config_path, use_defaults=True):
    """
    Load configuration from file.
    
    Args:
        config_path: Path to config file
        use_defaults: Whether to return defaults if file missing
    
    Returns:
        Configuration dict
    
    Raises:
        FileNotFoundError: If file missing and use_defaults=False
    """
    # Check if file exists
    if not os.path.exists(config_path):
        if use_defaults:
            logger.warning(f"Config file not found: {config_path}, using defaults")
            return get_default_config()
        else:
            raise FileNotFoundError(f"Config file not found: {config_path}")
    
    try:
        with open(config_path, 'r') as f:
            config = json.load(f)
        logger.info(f"Loaded config from {config_path}")
        return config
    
    except json.JSONDecodeError as e:
        logger.error(f"Invalid JSON in config file: {e}")
        raise
    except PermissionError:
        logger.error(f"Permission denied reading config: {config_path}")
        raise

def get_default_config():
    """Return default configuration"""
    return {
        'host': 'localhost',
        'port': 8080,
        'debug': False,
        'timeout': 30
    }

How I Prevent Runtime Errors

1. Input Validation

def process_payment(amount, currency='USD'):
    """Process payment with validation"""
    # Validate amount
    if not isinstance(amount, (int, float)):
        raise TypeError(f"Amount must be numeric, got {type(amount)}")
    
    if amount <= 0:
        raise ValueError(f"Amount must be positive, got {amount}")
    
    # Validate currency
    valid_currencies = ['USD', 'EUR', 'GBP']
    if currency not in valid_currencies:
        raise ValueError(f"Invalid currency: {currency}")
    
    # Process payment
    return execute_payment(amount, currency)

2. Defensive Programming with Try-Except

def fetch_and_process_data(url):
    """Fetch data from URL and process it"""
    try:
        # Network request might fail
        response = requests.get(url, timeout=10)
        response.raise_for_status()
        
        # JSON parsing might fail
        data = response.json()
        
        # Processing might fail
        result = process_data(data)
        
        return result
    
    except requests.Timeout:
        logger.error(f"Timeout fetching data from {url}")
        raise
    except requests.RequestException as e:
        logger.error(f"Network error: {e}")
        raise
    except json.JSONDecodeError:
        logger.error(f"Invalid JSON response from {url}")
        raise
    except Exception as e:
        logger.error(f"Unexpected error processing data: {e}")
        raise

3. Use Context Managers for Resources

# Ensures file is always closed, even if error occurs
def read_file_safely(filepath):
    """Read file with automatic cleanup"""
    try:
        with open(filepath, 'r') as f:
            content = f.read()
        return content
    except FileNotFoundError:
        logger.error(f"File not found: {filepath}")
        return None
    except PermissionError:
        logger.error(f"Permission denied: {filepath}")
        return None

Arithmetic Errors

What Are Arithmetic Errors?

Arithmetic errors occur during mathematical operations, including division by zero, overflow/underflow, precision loss, and incorrect operator usage.

Real-World Examples

Floating-Point Precision Issues

From a financial calculation module:

# Incorrect - Floating point precision problems
def calculate_total(prices):
    """Calculate total price"""
    total = 0.0
    for price in prices:
        total += price
    return total

# Problem with floating point arithmetic
prices = [0.1, 0.1, 0.1]
total = calculate_total(prices)
print(total)  # 0.30000000000000004 (not exactly 0.3!)

# This can cause issues in financial calculations
if total == 0.3:  # False!
    apply_discount()

Correct version:

from decimal import Decimal

def calculate_total(prices):
    """Calculate total price with precise decimal arithmetic"""
    total = Decimal('0.00')
    for price in prices:
        total += Decimal(str(price))
    return total

# Correct arithmetic
prices = [0.1, 0.1, 0.1]
total = calculate_total(prices)
print(total)  # Decimal('0.3') - exactly 0.3

# Better: With rounding for currency
def calculate_total_currency(prices):
    """Calculate total with proper currency rounding"""
    total = Decimal('0.00')
    for price in prices:
        total += Decimal(str(price))
    # Round to 2 decimal places for currency
    return total.quantize(Decimal('0.01'))

Integer Overflow (Less Common in Python)

# Python handles large integers automatically
# But other languages have overflow issues

# Example: Calculating factorial
def factorial(n):
    """Calculate factorial (can get very large)"""
    result = 1
    for i in range(1, n + 1):
        result *= i
    return result

# Python handles this fine, but be aware of performance
big_factorial = factorial(100)  # Works, but huge number
print(len(str(big_factorial)))  # 158 digits!

# Better: Add limits for practical use
def factorial(n, max_n=100):
    """Calculate factorial with reasonable limit"""
    if n > max_n:
        raise ValueError(f"n too large: {n} > {max_n}")
    
    if n < 0:
        raise ValueError("n must be non-negative")
    
    result = 1
    for i in range(1, n + 1):
        result *= i
    return result

Modulo Operation with Zero

# Incorrect - No check for zero divisor
def get_batch_index(item_number, batch_size):
    """Determine which batch an item belongs to"""
    return item_number % batch_size

# Crashes with batch_size = 0
index = get_batch_index(10, 0)  # ZeroDivisionError

Correct version:

def get_batch_index(item_number, batch_size):
    """
    Determine which batch an item belongs to.
    
    Args:
        item_number: Item index (0-based)
        batch_size: Size of each batch
    
    Returns:
        Batch index
    
    Raises:
        ValueError: If batch_size is not positive
    """
    if batch_size <= 0:
        raise ValueError(f"Batch size must be positive, got {batch_size}")
    
    return item_number % batch_size

Incorrect Rounding

From a pricing calculator:

# Incorrect - Banker's rounding vs expected rounding
def calculate_price_per_unit(total_price, quantity):
    """Calculate price per unit"""
    price_per_unit = total_price / quantity
    # Python's round() uses banker's rounding
    return round(price_per_unit, 2)

# Banker's rounding rounds 0.5 to nearest even number
# round(2.5) = 2, round(3.5) = 4
# This can be confusing for financial calculations

Correct version:

from decimal import Decimal, ROUND_HALF_UP

def calculate_price_per_unit(total_price, quantity):
    """
    Calculate price per unit with proper rounding.
    
    Uses ROUND_HALF_UP (traditional rounding: 0.5 rounds up)
    """
    if quantity == 0:
        raise ValueError("Quantity cannot be zero")
    
    # Use Decimal for precise calculation
    price = Decimal(str(total_price)) / Decimal(str(quantity))
    
    # Round to 2 decimal places, 0.5 rounds up
    return price.quantize(Decimal('0.01'), rounding=ROUND_HALF_UP)

# Example
price = calculate_price_per_unit(10, 3)
print(price)  # Decimal('3.33')

How I Prevent Arithmetic Errors

1. Use Appropriate Data Types

# For money: use Decimal
from decimal import Decimal

class PriceCalculator:
    def __init__(self):
        self.tax_rate = Decimal('0.08')  # 8% tax
    
    def calculate_total(self, subtotal):
        """Calculate total with tax"""
        subtotal_decimal = Decimal(str(subtotal))
        tax = subtotal_decimal * self.tax_rate
        total = subtotal_decimal + tax
        return total.quantize(Decimal('0.01'))

2. Validate Before Operations

def safe_divide(numerator, denominator):
    """Safe division with validation"""
    if denominator == 0:
        raise ValueError("Cannot divide by zero")
    
    return numerator / denominator

def safe_percentage(part, whole):
    """Calculate percentage safely"""
    if whole == 0:
        return 0.0
    
    return (part / whole) * 100

3. Handle Edge Cases

import math

def calculate_average(numbers):
    """Calculate average handling edge cases"""
    if not numbers:
        return 0.0
    
    # Handle very large numbers
    total = sum(numbers)
    avg = total / len(numbers)
    
    # Check for infinity or NaN
    if math.isinf(avg):
        raise ValueError("Result is infinite")
    if math.isnan(avg):
        raise ValueError("Result is NaN")
    
    return avg

Practical Testing Strategies

Unit Tests for Runtime Scenarios

import pytest

def test_division_by_zero():
    """Test that division by zero is handled"""
    with pytest.raises(ValueError):
        calculate_success_rate(10, 0)

def test_invalid_input_type():
    """Test that invalid types are rejected"""
    with pytest.raises(ValueError):
        set_timeout("invalid")

def test_missing_key_in_response():
    """Test handling of malformed API responses"""
    response = {'error': 'Not found'}
    result = get_user_email_from_response(response)
    assert result is None

def test_empty_list():
    """Test processing empty input"""
    result = calculate_average([])
    assert result == 0.0

Property-Based Testing

from hypothesis import given, strategies as st

@given(st.lists(st.floats(min_value=0.01, max_value=1000000)))
def test_calculate_total_always_positive(prices):
    """Total should always be positive for positive prices"""
    total = calculate_total_currency(prices)
    assert total >= 0

@given(
    st.integers(min_value=1, max_value=1000),
    st.integers(min_value=1, max_value=100)
)
def test_batch_index_in_range(item_number, batch_size):
    """Batch index should always be less than batch size"""
    index = get_batch_index(item_number, batch_size)
    assert 0 <= index < batch_size

Tools I Use

Error Tracking

# Sentry for production error tracking
import sentry_sdk

sentry_sdk.init(dsn="your-dsn-here")

def risky_operation():
    try:
        # Code that might fail
        result = perform_operation()
    except Exception as e:
        sentry_sdk.capture_exception(e)
        raise

Logging

import logging
from logging.handlers import RotatingFileHandler

# Configure logging
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)

# File handler with rotation
file_handler = RotatingFileHandler(
    'app.log',
    maxBytes=10485760,  # 10MB
    backupCount=5
)
file_handler.setLevel(logging.ERROR)

# Format
formatter = logging.Formatter(
    '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)

Key Takeaways

1. Validate all inputs: Never trust user data or external sources

2. Handle exceptions explicitly: Catch specific exceptions, not generic Exception

3. Use appropriate data types: Decimal for money, int for counts

4. Test edge cases: Empty lists, zero values, None, negative numbers

5. Log errors properly: Include context for debugging

6. Fail fast: Validate early, before processing begins

7. Use context managers: Ensure resources are cleaned up

Next in Series

In Part 4: Resource and Performance Errors, we'll explore errors related to system resources—memory leaks, file handle exhaustion, and performance bottlenecks that can bring your application to its knees under load.

---

Based on debugging production incidents in payment processing systems, API services, and data analytics platforms.