Part 2: Logic and Semantic Errors

Introduction

After shipping my first automation tool that processed server logs, I discovered it had been calculating uptime percentages incorrectly for three weeks. The code ran perfectly—no crashes, no error messages—but the numbers were wrong. This was my introduction to logic errors: the silent bugs that are often the hardest to catch.

Unlike syntax errors that prevent code from running, logic and semantic errors let your program execute while producing incorrect results. These are the bugs that make it to production.

Logic Errors

What Are Logic Errors?

Logic errors occur when your code runs successfully but doesn't do what you intended. The syntax is correct, the types match, but the algorithm or reasoning is flawed.

Real-World Examples from My Projects

Off-by-One Errors in List Processing

From a data processing pipeline I built:

# Incorrect - Processing one less item than intended
def process_daily_metrics(metrics):
    """Process all daily metrics"""
    results = []
    for i in range(len(metrics) - 1):  # Bug: Missing last item!
        results.append(calculate_metric(metrics[i]))
    return results

# Example usage
daily_data = [100, 200, 300, 400, 500]
processed = process_daily_metrics(daily_data)
# Returns only [calc(100), calc(200), calc(300), calc(400)]
# Missing the last item: 500

Correct version:

def process_daily_metrics(metrics):
    """Process all daily metrics"""
    results = []
    for i in range(len(metrics)):  # Correct: Process all items
        results.append(calculate_metric(metrics[i]))
    return results

# Better: Use Pythonic iteration
def process_daily_metrics(metrics):
    """Process all daily metrics"""
    return [calculate_metric(m) for m in metrics]

Incorrect Conditional Logic

From a user permission system I developed:

# Incorrect - Flawed logic for admin check
def has_admin_access(user):
    """Check if user has admin privileges"""
    # Bug: Using OR when AND is needed
    if user.role == 'admin' or user.department == 'IT':
        return True
    return False

# Problem: All IT department users get admin access!
# John from IT helpdesk shouldn't have admin privileges

Correct version:

def has_admin_access(user):
    """Check if user has admin privileges"""
    # Correct: Must be admin AND from approved department
    if user.role == 'admin' and user.department in ['IT', 'Management']:
        return True
    return False

# Better: More explicit
def has_admin_access(user):
    """Check if user has admin privileges"""
    admin_departments = ['IT', 'Management']
    return user.role == 'admin' and user.department in admin_departments

Average Calculation Error

From a metrics dashboard:

# Incorrect - Logic error in average calculation
def calculate_average_response_time(response_times):
    """Calculate average response time in milliseconds"""
    total = 0
    for time in response_times:
        total += time
    
    # Bug: Dividing by total instead of count!
    average = total / total  # Always returns 1.0
    return average

# Example
times = [100, 200, 300, 400]
avg = calculate_average_response_time(times)
# Returns 1.0 instead of 250.0

Correct version:

def calculate_average_response_time(response_times):
    """Calculate average response time in milliseconds"""
    if not response_times:
        return 0
    
    total = sum(response_times)
    average = total / len(response_times)
    return average

# Better: Using statistics module
from statistics import mean

def calculate_average_response_time(response_times):
    """Calculate average response time in milliseconds"""
    return mean(response_times) if response_times else 0

Loop Boundary Issues

From a batch processing script:

# Incorrect - Wrong loop condition
def process_batches(items, batch_size):
    """Process items in batches"""
    batches = []
    i = 0
    
    # Bug: Loop terminates early
    while i < len(items):
        batch = items[i:i + batch_size]
        batches.append(process_batch(batch))
        i += batch_size + 1  # Bug: Should be += batch_size
    
    return batches

# Example: With 10 items and batch_size=3
# Processes: [0:3], [4:7], [8:11]
# Skips items at indices 3 and 7!

Correct version:

def process_batches(items, batch_size):
    """Process items in batches"""
    batches = []
    i = 0
    
    while i < len(items):
        batch = items[i:i + batch_size]
        batches.append(process_batch(batch))
        i += batch_size  # Correct increment
    
    return batches

# Better: Using Python list slicing
def process_batches(items, batch_size):
    """Process items in batches"""
    return [
        process_batch(items[i:i + batch_size])
        for i in range(0, len(items), batch_size)
    ]

Common Logic Error Patterns

1. Comparison Operator Mistakes

# Incorrect - Should use == not =
if status = 'active':  # SyntaxError in Python, but logic error in other languages
    start_service()

# In conditions where valid syntax but wrong operator
if status >= 200:  # Should be > 200
    handle_success()

# Correct
if status == 'active':
    start_service()

if status > 200:
    handle_success()

2. Incorrect Boolean Logic

# Incorrect
def is_eligible_for_discount(age, member):
    # Bug: Senior OR member gets discount
    # Should be: Senior (65+) OR premium member
    return age > 65 or member == True

# 66-year-old non-member gets discount ✓ (correct)
# 30-year-old premium member gets discount ✓ (correct)
# But logic doesn't match business requirement

# Correct - Based on actual business logic
def is_eligible_for_discount(age, member_type):
    is_senior = age >= 65
    is_premium_member = member_type == 'premium'
    return is_senior or is_premium_member

3. Algorithm Selection Errors

# Incorrect - Using inefficient algorithm
def find_duplicate_ids(id_list):
    """Find duplicate IDs in list"""
    duplicates = []
    # O(n²) complexity - inefficient for large lists
    for i in range(len(id_list)):
        for j in range(i + 1, len(id_list)):
            if id_list[i] == id_list[j] and id_list[i] not in duplicates:
                duplicates.append(id_list[i])
    return duplicates

# Correct - Better algorithm using set
def find_duplicate_ids(id_list):
    """Find duplicate IDs in list"""
    seen = set()
    duplicates = set()
    
    for id_val in id_list:
        if id_val in seen:
            duplicates.add(id_val)
        seen.add(id_val)
    
    return list(duplicates)

# Or using Counter
from collections import Counter

def find_duplicate_ids(id_list):
    """Find duplicate IDs in list"""
    counts = Counter(id_list)
    return [id_val for id_val, count in counts.items() if count > 1]

How I Catch Logic Errors

1. Write Unit Tests First (TDD Approach)

I adopted Test-Driven Development after too many logic bugs:

# test_metrics.py
import pytest
from metrics import calculate_average_response_time

def test_average_calculation_normal_case():
    """Test average with typical values"""
    response_times = [100, 200, 300, 400]
    expected = 250.0
    assert calculate_average_response_time(response_times) == expected

def test_average_calculation_empty_list():
    """Test average with empty input"""
    assert calculate_average_response_time([]) == 0

def test_average_calculation_single_value():
    """Test average with single value"""
    assert calculate_average_response_time([100]) == 100.0

def test_average_calculation_large_numbers():
    """Test average with large values"""
    response_times = [10000, 20000, 30000]
    expected = 20000.0
    assert calculate_average_response_time(response_times) == expected

Run tests:

pytest test_metrics.py -v

2. Use Assertions to Validate Assumptions

def process_user_data(user_dict):
    """Process user data with assumption validation"""
    # Validate assumptions about input
    assert isinstance(user_dict, dict), "user_dict must be a dictionary"
    assert 'id' in user_dict, "user_dict must contain 'id'"
    assert user_dict['id'] > 0, "user_dict['id'] must be positive"
    
    # Process data
    user_id = user_dict['id']
    return process_id(user_id)

3. Debug with Print Statements and Logging

import logging

logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger(__name__)

def calculate_discount(price, discount_rate):
    """Calculate discounted price"""
    logger.debug(f"Input: price={price}, discount_rate={discount_rate}")
    
    discount_amount = price * discount_rate
    logger.debug(f"Discount amount: {discount_amount}")
    
    final_price = price - discount_amount
    logger.debug(f"Final price: {final_price}")
    
    return final_price

4. Code Review with Peers

Having another developer review logic helps catch errors I miss. I use GitHub PRs for all code changes, even on personal projects.

Semantic Errors

What Are Semantic Errors?

Semantic errors occur when code is syntactically correct and runs without crashing, but the meaning or interpretation of what the code does is wrong. The code doesn't match the intended behavior.

Real-World Examples

Incorrect Formula Implementation

From a financial calculation service:

# Incorrect - Wrong formula for compound interest
def calculate_compound_interest(principal, rate, years):
    """Calculate compound interest"""
    # Bug: Using simple interest formula instead of compound
    interest = principal * rate * years
    return principal + interest

# Example: $1000 at 5% for 3 years
# Returns: 1000 + (1000 * 0.05 * 3) = 1150
# Should be: 1000 * (1.05)^3 = 1157.63

Correct version:

def calculate_compound_interest(principal, rate, years):
    """Calculate compound interest"""
    # Correct formula: A = P(1 + r)^t
    amount = principal * ((1 + rate) ** years)
    return amount

# Better: With documentation
def calculate_compound_interest(principal, rate, years, compounds_per_year=1):
    """
    Calculate compound interest.
    
    Formula: A = P(1 + r/n)^(nt)
    where:
        A = final amount
        P = principal
        r = annual interest rate (decimal)
        n = compounds per year
        t = years
    """
    amount = principal * ((1 + rate / compounds_per_year) ** (compounds_per_year * years))
    return amount

Type Confusion

From a data validation module:

# Incorrect - Semantic error with type handling
def validate_port_number(port):
    """Validate if port number is valid"""
    # Bug: String comparison instead of numeric
    if port > "1024" and port < "65535":  # Works but wrong!
        return True
    return False

# Problem: "9000" > "1024" is True (string comparison)
# But: "9000" > "10000" is False (lexicographic order)

Correct version:

def validate_port_number(port):
    """Validate if port number is valid"""
    # Ensure numeric comparison
    try:
        port_num = int(port)
        return 1024 < port_num < 65535
    except (ValueError, TypeError):
        return False

# Better: With clear error messages
def validate_port_number(port):
    """
    Validate if port number is in valid range.
    
    Valid range: 1025-65534 (non-privileged ports)
    """
    try:
        port_num = int(port)
        if not (1024 < port_num < 65535):
            raise ValueError(f"Port {port_num} outside valid range 1025-65534")
        return True
    except (ValueError, TypeError) as e:
        logger.error(f"Invalid port number: {e}")
        return False

Misunderstanding API Behavior

From an integration with an external API:

# Incorrect - Misunderstanding API response
def get_user_status(user_id):
    """Get user active status"""
    response = api.get_user(user_id)
    
    # Bug: Assuming 'status' field means 'active'
    # API actually returns 'status': 'pending'|'active'|'suspended'
    return response['status']  # Returns string, not boolean

# Used incorrectly elsewhere
if get_user_status(123):  # Always True if status field exists!
    grant_access()

Correct version:

def is_user_active(user_id):
    """Check if user has active status"""
    response = api.get_user(user_id)
    
    # Explicitly check for active status
    return response.get('status') == 'active'

# Better: Handle all cases
def get_user_status(user_id):
    """Get user status with proper handling"""
    response = api.get_user(user_id)
    status = response.get('status', 'unknown')
    
    valid_statuses = ['pending', 'active', 'suspended', 'inactive']
    if status not in valid_statuses:
        logger.warning(f"Unknown status '{status}' for user {user_id}")
        return 'unknown'
    
    return status

How I Prevent Semantic Errors

1. Clear Documentation and Comments

def calculate_tax(amount, tax_rate):
    """
    Calculate tax amount.
    
    Args:
        amount (float): Pre-tax amount in dollars
        tax_rate (float): Tax rate as decimal (e.g., 0.08 for 8%)
    
    Returns:
        float: Tax amount (not total with tax)
    
    Example:
        >>> calculate_tax(100, 0.08)
        8.0
    """
    return amount * tax_rate

2. Use Type Hints

from typing import List, Dict, Optional

def process_transactions(
    transactions: List[Dict[str, float]], 
    fee_rate: float
) -> Optional[float]:
    """
    Process list of transactions and calculate total with fees.
    
    Args:
        transactions: List of transaction dicts with 'amount' key
        fee_rate: Fee as decimal (0.03 for 3%)
    
    Returns:
        Total amount including fees, or None if invalid input
    """
    if not transactions:
        return None
    
    total = sum(t['amount'] for t in transactions)
    total_with_fees = total * (1 + fee_rate)
    return total_with_fees

3. Write Examples and Doctests

def celsius_to_fahrenheit(celsius):
    """
    Convert Celsius to Fahrenheit.
    
    Formula: F = (C × 9/5) + 32
    
    Examples:
        >>> celsius_to_fahrenheit(0)
        32.0
        >>> celsius_to_fahrenheit(100)
        212.0
        >>> celsius_to_fahrenheit(-40)
        -40.0
    """
    return (celsius * 9/5) + 32

# Run doctests
if __name__ == "__main__":
    import doctest
    doctest.testmod()

4. Validate Against Known Values

def test_formula_with_known_values():
    """Test implementation against known correct values"""
    # Known: $1000 at 5% for 10 years compounds to $1628.89
    result = calculate_compound_interest(1000, 0.05, 10)
    expected = 1628.89
    assert abs(result - expected) < 0.01, f"Expected {expected}, got {result}"

Practical Debugging Strategies

Finding Logic Errors

1. Write tests for edge cases: Empty lists, zero values, negative numbers

2. Use a debugger: Step through code line by line

3. Add strategic logging: Log inputs, intermediate values, and outputs

4. Rubber duck debugging: Explain code logic out loud

Finding Semantic Errors

1. Review requirements: Ensure understanding matches specification

2. Cross-reference documentation: Verify API behavior assumptions

3. Use code examples: Test against documented examples

4. Peer review: Have someone else validate your interpretation

Tools I Use

Testing Frameworks

# Install pytest
pip install pytest pytest-cov

# Run tests with coverage
pytest --cov=mymodule tests/

# Run with verbose output
pytest -v -s

Static Type Checking

# Install mypy
pip install mypy

# Check types
mypy my_script.py

Debugging

# Using pdb (Python debugger)
import pdb

def problematic_function(data):
    pdb.set_trace()  # Debugger stops here
    result = process_data(data)
    return result

# Or use breakpoint() in Python 3.7+
def problematic_function(data):
    breakpoint()  # More Pythonic
    result = process_data(data)
    return result

Key Takeaways

1. Logic errors are silent killers: They don't crash; they corrupt

2. Test, test, test: Unit tests catch logic errors early

3. Validate assumptions: Use assertions and type hints

4. Document intent: Clear documentation prevents semantic errors

5. Review and verify: Peer review catches errors you miss

6. Use the right algorithm: Big-O matters at scale

Next in Series

In Part 3: Runtime and Arithmetic Errors, we'll explore errors that occur during execution—division by zero, type errors, and numerical precision issues that can crash your application or produce incorrect calculations.

---

Lessons learned from debugging production issues in automation tools, web services, and data processing pipelines.