Copy-Paste Code Bugs — Why One Function Beats Ten Copies

package io.thecodeforge.cs;

public class OrderPricingService {

    public static void main(String[] args) {

        // Store the price in CENTS (integer), never floating-point dollars.
        // Floats cannot represent 0.10 exactly — this has caused real billing bugs.
        int unitPriceInCents = 1099;   // $10.99 per item
        int quantityOrdered  = 3;      // How many the customer wants

        // A boolean that controls downstream logic — shipping rules, tax rules, etc.
        // Name it as a statement that is either true or false, never 'flag' or 'status'.
        boolean isEligibleForFreeShipping = false;

        // String for human-readable display only — never do arithmetic on this.
        String productName = "Wireless Keyboard";

        // Calculate total: integer multiplication — no floating-point rounding errors.
        int orderTotalInCents = unitPriceInCents * quantityOrdered;

        // Apply free shipping threshold: orders over $50 (5000 cents) qualify.
        // We check BEFORE formatting, so the logic lives here — not scattered in the UI.
        if (orderTotalInCents >= 5000) {
            isEligibleForFreeShipping = true;
        }

        // Format for display ONLY at the very end — never store dollars as a double.
        double orderTotalInDollars = orderTotalInCents / 100.0;

        System.out.println("Product       : " + productName);
        System.out.println("Unit price    : $" + String.format("%.2f", unitPriceInCents / 100.0));
        System.out.println("Quantity      : " + quantityOrdered);
        System.out.println("Order total   : $" + String.format("%.2f", orderTotalInDollars));
        System.out.println("Free shipping : " + isEligibleForFreeShipping);
    }
}

package io.thecodeforge.cs;

public class DiscountCalculator {

    /**
     * Calculates the discounted price in cents.
     * Single responsibility: take a price and a discount rate, return the result.
     * No side effects — doesn't print, doesn't update a database, doesn't log.
     * That makes it testable in isolation without mocking anything.
     *
     * @param originalPriceInCents  The pre-discount price (must be >= 0)
     * @param discountPercentage    Discount as a whole number 0-100 (e.g. 20 means 20% off)
     * @return                      The price after discount, in cents
     */
    public static int calculateDiscountedPrice(int originalPriceInCents, int discountPercentage) {

        // Guard clause: reject bad input immediately rather than silently computing garbage.
        // Failing fast here beats returning a wrong price that reaches the payment processor.
        if (originalPriceInCents < 0) {
            throw new IllegalArgumentException("Price cannot be negative: " + originalPriceInCents);
        }
        if (discountPercentage < 0 || discountPercentage > 100) {
            throw new IllegalArgumentException("Discount must be 0-100, got: " + discountPercentage);
        }

        // Calculate discount amount first, then subtract — avoids floating-point math.
        int discountAmountInCents = (originalPriceInCents * discountPercentage) / 100;
        return originalPriceInCents - discountAmountInCents;
    }

    /**
     * Formats a cent value into a human-readable dollar string.
     * Separate function because formatting is a different job from calculating.
     * Now you can change your currency display format in one place.
     */
    public static String formatAsDollars(int amountInCents) {
        return String.format("$%.2f", amountInCents / 100.0);
    }

    public static void main(String[] args) {

        int originalPrice = 4999;  // $49.99
        int discountRate  = 20;    // 20% off

        // Call the function — same logic works for every product without copy-pasting.
        int discountedPrice = calculateDiscountedPrice(originalPrice, discountRate);

        System.out.println("Original price  : " + formatAsDollars(originalPrice));
        System.out.println("Discount        : " + discountRate + "%");
        System.out.println("Discounted price: " + formatAsDollars(discountedPrice));
        System.out.println("You save        : " + formatAsDollars(originalPrice - discountedPrice));
    }
}

package io.thecodeforge.cs;

import java.util.Arrays;
import java.util.List;

public class ShoppingCartProcessor {

    // Represents a single item in a shopping cart.
    // Using a record-style structure so the data is obvious at a glance.
    static class CartItem {
        String  productName;
        int     priceInCents;
        int     quantity;
        boolean isPerishable;  // Perishables need cold-chain shipping — different logic applies.

        CartItem(String productName, int priceInCents, int quantity, boolean isPerishable) {
            this.productName  = productName;
            this.priceInCents = priceInCents;
            this.quantity     = quantity;
            this.isPerishable = isPerishable;
        }
    }

    public static void main(String[] args) {

        // A realistic cart — three different products, one perishable.
        List<CartItem> cart = Arrays.asList(
            new CartItem("Wireless Keyboard",  4999, 1, false),
            new CartItem("USB-C Hub",          2999, 2, false),
            new CartItem("Organic Greek Yoghurt", 349, 4, true)
        );

        int cartTotalInCents    = 0;
        boolean requiresColdChain = false;  // Flipped to true if ANY item is perishable.

        // for-each loop: we don't need an index, we just need every item.
        // This is clearer than a traditional for-loop when index doesn't matter.
        for (CartItem item : cart) {

            // Calculate line total for this item.
            int lineTotalInCents = item.priceInCents * item.quantity;
            cartTotalInCents += lineTotalInCents;  // Accumulate into the cart total.

            // Conditional: check if this item forces cold-chain shipping.
            // Once true, it stays true — one perishable item affects the whole order.
            if (item.isPerishable) {
                requiresColdChain = true;
            }

            System.out.printf("  %-25s x%d  = $%.2f%n",
                item.productName,
                item.quantity,
                lineTotalInCents / 100.0);
        }

        System.out.println("  ─────────────────────────────────────────");
        System.out.printf("  Cart total: $%.2f%n", cartTotalInCents / 100.0);

        // Conditional with else: only one path runs — not both.
        if (requiresColdChain) {
            System.out.println("  Shipping: Cold-chain required (+$12.99 surcharge)");
        } else {
            System.out.println("  Shipping: Standard");
        }
    }
}

package io.thecodeforge.cs;

import java.util.*;

public class ProductCatalogueService {

    // Represents a product in the catalogue.
    static class Product {
        String productId;    // Unique identifier — this becomes our HashMap key.
        String name;
        int    priceInCents;
        String category;

        Product(String productId, String name, int priceInCents, String category) {
            this.productId    = productId;
            this.name         = name;
            this.priceInCents = priceInCents;
            this.category     = category;
        }
    }

    public static void main(String[] args) {

        // HashMap<Key, Value>: productId → Product object.
        // Lookup by productId is O(1) — constant time regardless of catalogue size.
        // If this were a List, lookup would be O(n) — slower as catalogue grows.
        Map<String, Product> catalogue = new HashMap<>();

        // Load catalogue — in production this would come from a database or cache.
        catalogue.put("KB-001", new Product("KB-001", "Wireless Keyboard", 4999, "Peripherals"));
        catalogue.put("HB-002", new Product("HB-002", "USB-C Hub",         2999, "Peripherals"));
        catalogue.put("MN-003", new Product("MN-003", "4K Monitor",       34999, "Displays"));
        catalogue.put("MS-004", new Product("MS-004", "Ergonomic Mouse",   3499, "Peripherals"));

        // Simulate an incoming order with product IDs — exactly what an API receives.
        List<String> orderedProductIds = Arrays.asList("KB-001", "MN-003", "XX-999");

        // Set to track which categories appear in this order — no duplicates needed.
        Set<String> categoriesInOrder = new HashSet<>();

        int orderTotalInCents = 0;

        System.out.println("Processing order:");

        for (String productId : orderedProductIds) {

            // HashMap.get() is O(1) — instant lookup, no matter how big the catalogue is.
            Product product = catalogue.get(productId);

            if (product == null) {
                // Product not found — log it and skip. Don't crash the whole order.
                System.out.println("  WARNING: Product not found in catalogue: " + productId);
                continue;  // Skip to the next item in the loop.
            }

            orderTotalInCents += product.priceInCents;

            // Set.add() ignores duplicates automatically — no need for an if-check.
            categoriesInOrder.add(product.category);

            System.out.printf("  %-10s %-25s $%.2f%n",
                product.productId,
                product.name,
                product.priceInCents / 100.0);
        }

        System.out.println("  ──────────────────────────────────────────");
        System.out.printf("  Order total: $%.2f%n", orderTotalInCents / 100.0);
        System.out.println("  Categories in this order: " + categoriesInOrder);
    }
}

package io.thecodeforge.cs;

import java.util.logging.Logger;

public class PaymentProcessor {

    private static final Logger logger = Logger.getLogger(PaymentProcessor.class.getName());

    /**
     * Attempts to charge a customer.
     * Fails fast if inputs are invalid, fails clearly by logging the cause,
     * and fails recoverably by throwing a checked exception the caller can handle.
     */
    public static boolean chargeCustomer(String customerId, int amountInCents) {
        // Guard clause: fail fast on invalid input
        if (customerId == null || customerId.isBlank()) {
            throw new IllegalArgumentException("Customer ID must not be null or blank");
        }
        if (amountInCents <= 0) {
            throw new IllegalArgumentException("Amount must be positive, got: " + amountInCents);
        }

        try {
            // Simulated payment gateway call (could throw IOException, timeout, etc.)
            boolean success = PaymentGateway.charge(customerId, amountInCents);
            if (!success) {
                // Fail clearly: log the specific failure
                logger.warning("Payment declined for customer " + customerId + " amount " + amountInCents);
            }
            return success;

        } catch (PaymentGatewayTimeoutException e) {
            // Fail recoverably: log and rethrow as a checked exception so caller decides retry or fallback
            logger.severe("Payment gateway timeout for customer " + customerId + ": " + e.getMessage());
            throw new PaymentProcessingException("Unable to process payment, try again later", e);

        } catch (Exception e) {
            // Catch-all for unexpected errors — log FULL context, don't swallow
            logger.severe("Unexpected payment failure for customer " + customerId + ": " + e.getMessage());
            throw new PaymentProcessingException("Internal payment error", e);
        }
    }

    // Custom exception class so callers can handle payment failures specifically
    static class PaymentProcessingException extends RuntimeException {
        public PaymentProcessingException(String message, Throwable cause) {
            super(message, cause);
        }
    }

    // Stub for demonstration
    static class PaymentGateway {
        static boolean charge(String customerId, int amountInCents) throws PaymentGatewayTimeoutException {
            // simulate
            return true;
        }
    }

    static class PaymentGatewayTimeoutException extends Exception {
        public PaymentGatewayTimeoutException(String message) {
            super(message);
        }
    }
}