# The "quick fix" that becomes permanent
ps aux | grep nginx | awk '{print $2}' | xargs kill -9

# Instead of this monolithic approach:
# check_disk_space_and_clean_logs_and_restart_service.sh

# Build modular functions:
check_disk_space() { ... }
clean_old_logs() { ... }
restart_service_safely() { ... }
send_notification() { ... }

# Then compose them:
main() {
    if ! check_disk_space; then
        clean_old_logs
        restart_service_safely "nginx"
        send_notification "Disk cleanup performed"
    fi
}

# Instead of hoping curl works:
curl https://api.example.com/data

# Professional approach:
fetch_api_data() {
    local url="$1"
    local max_retries=3
    local retry_count=0
    
    while [[ $retry_count -lt $max_retries ]]; do
        if response=$(curl -sf "$url" 2>/dev/null); then
            echo "$response"
            return 0
        fi
        
        ((retry_count++))
        log_warning "API call failed (attempt $retry_count/$max_retries)"
        [[ $retry_count -lt $max_retries ]] && sleep 5
    done
    
    log_error "Failed to fetch data from $url after $max_retries attempts"
    return 1
}

# Default configuration
DEFAULT_TIMEOUT=30
DEFAULT_RETRY_COUNT=3
DEFAULT_LOG_LEVEL="INFO"

# Allow environment overrides
TIMEOUT=${TIMEOUT:-$DEFAULT_TIMEOUT}
RETRY_COUNT=${RETRY_COUNT:-$DEFAULT_RETRY_COUNT}
LOG_LEVEL=${LOG_LEVEL:-$DEFAULT_LOG_LEVEL}

# Command-line arguments override everything
while [[ $# -gt 0 ]]; do
    case $1 in
        --timeout) TIMEOUT="$2"; shift 2 ;;
        --retries) RETRY_COUNT="$2"; shift 2 ;;
        --verbose) LOG_LEVEL="DEBUG"; shift ;;
        *) echo "Unknown option: $1"; exit 1 ;;
    esac
done

# Instead of one giant script, think in modules:

# Core monitoring functions
monitor_cpu_usage()
monitor_memory_usage()
monitor_disk_space()
monitor_services()

# Alerting system
send_email_alert()
send_slack_notification()
log_alert()

# Configuration management
load_config()
validate_config()
set_defaults()

# Utility functions
log_message()
handle_error()
cleanup_on_exit()

# Main orchestration
main()

# Beginner: Fixed threshold
if [[ $cpu_usage -gt 80 ]]; then

# Advanced: Context-aware thresholds
calculate_threshold() {
    local base_threshold=80
    local current_hour=$(date +%H)
    
    # Higher threshold during business hours
    if [[ $current_hour -ge 9 && $current_hour -le 17 ]]; then
        echo $((base_threshold + 10))
    else
        echo $base_threshold
    fi
}

# Instead of cryptic variable names:
t=80; m=90; d=95

# Use descriptive names that explain intent:
CPU_WARNING_THRESHOLD=80
MEMORY_CRITICAL_THRESHOLD=90
DISK_EMERGENCY_THRESHOLD=95

# If email fails, try alternative notification methods
send_notification() {
    local message="$1"
    
    if ! send_email "$message"; then
        log_warning "Email notification failed, trying Slack"
        if ! send_slack "$message"; then
            log_warning "Slack notification failed, logging locally"
            log_alert "$message"
        fi
    fi
}

validate_environment() {
    # Check required commands
    for cmd in curl jq systemctl; do
        if ! command -v "$cmd" >/dev/null 2>&1; then
            log_error "Required command not found: $cmd"
            return 1
        fi
    done
    
    # Check required files
    for file in "/etc/passwd" "/proc/loadavg"; do
        if [[ ! -r "$file" ]]; then
            log_error "Cannot read required file: $file"
            return 1
        fi
    done
    
    return 0
}

main() {
    # Fail fast if environment isn't ready
    validate_environment || exit 1
    
    # Now we can proceed with confidence
    run_monitoring_checks
}

# States: STARTING -> MONITORING -> ALERTING -> RECOVERING -> MONITORING
SCRIPT_STATE="STARTING"

transition_to() {
    local new_state="$1"
    log_debug "State transition: $SCRIPT_STATE -> $new_state"
    SCRIPT_STATE="$new_state"
}

handle_current_state() {
    case "$SCRIPT_STATE" in
        "STARTING")
            initialize_monitoring
            transition_to "MONITORING"
            ;;
        "MONITORING")
            if detect_issues; then
                transition_to "ALERTING"
            fi
            ;;
        "ALERTING")
            send_alerts
            transition_to "RECOVERING"
            ;;
        "RECOVERING")
            attempt_recovery
            transition_to "MONITORING"
            ;;
    esac
}

# Core framework provides the structure
run_monitoring_plugins() {
    local plugin_dir="/etc/monitoring/plugins"
    
    if [[ -d "$plugin_dir" ]]; then
        for plugin in "$plugin_dir"/*.sh; do
            if [[ -x "$plugin" ]]; then
                log_debug "Running plugin: $(basename "$plugin")"
                if ! "$plugin"; then
                    log_warning "Plugin failed: $(basename "$plugin")"
                fi
            fi
        done
    fi
}

# Plugins are simple, focused scripts:
# /etc/monitoring/plugins/check-database.sh
# /etc/monitoring/plugins/check-website.sh
# /etc/monitoring/plugins/check-certificates.sh

show_help() {
    cat << 'EOF'
System Monitor v2.0

USAGE:
    monitor.sh [OPTIONS] [COMMAND]

COMMANDS:
    start       Start continuous monitoring
    check       Run single check
    status      Show current status

OPTIONS:
    --config FILE    Use custom config file
    --verbose        Enable debug output
    --dry-run        Show what would be done

EXAMPLES:
    monitor.sh check --verbose
    monitor.sh start --config /etc/custom.conf
    
EOF
}

find_config_file() {
    # Check multiple locations in order of preference
    local config_locations=(
        "${CONFIG_FILE:-}"                    # Command line
        "${HOME}/.config/monitor/config"      # User config
        "/etc/monitor/config"                 # System config
        "${SCRIPT_DIR}/config"                # Script directory
    )
    
    for location in "${config_locations[@]}"; do
        if [[ -n "$location" && -r "$location" ]]; then
            echo "$location"
            return 0
        fi
    done
    
    return 1
}

detect_environment() {
    if [[ -f /.dockerenv ]]; then
        echo "container"
    elif [[ -n "${KUBERNETES_SERVICE_HOST:-}" ]]; then
        echo "kubernetes"
    elif [[ -n "${AWS_REGION:-}" ]]; then
        echo "aws"
    else
        echo "traditional"
    fi
}

adjust_for_environment() {
    local env=$(detect_environment)
    
    case "$env" in
        "container")
            # Adjust monitoring for container limits
            use_cgroup_metrics
            ;;
        "kubernetes")
            # Use k8s APIs for service discovery
            discover_services_via_k8s
            ;;
        "aws")
            # Integrate with CloudWatch
            send_metrics_to_cloudwatch
            ;;
    esac
}