CPU-Intensive Operations

// Anti-pattern: Blocking the main thread with heavy computation
function calculatePrimes(max) {
  const primes = [];
  for (let i = 2; i <= max; i++) {
    let isPrime = true;
    for (let j = 2; j < i; j++) {
      if (i % j === 0) {
        isPrime = false;
        break;
      }
    }
    if (isPrime) primes.push(i);
  }
  return primes;
}

// In a web application
document.getElementById('calculate-btn').addEventListener('click', () => {
  // This will freeze the UI while calculating
  const primes = calculatePrimes(100000);
  displayResults(primes);
});

// Better approach: Using Web Workers for CPU-intensive tasks
document.getElementById('calculate-btn').addEventListener('click', () => {
  const worker = new Worker('primes-worker.js');
  
  worker.onmessage = (event) => {
    displayResults(event.data);
  };
  
  worker.postMessage(100000);
});

// In primes-worker.js
self.onmessage = (event) => {
  const max = event.data;
  const primes = calculatePrimes(max);
  self.postMessage(primes);
};

// Anti-pattern: Blocking the UI thread in Android
public void onCalculateButtonClick(View view) {
    // This will freeze the UI while calculating
    List<Integer> primes = calculatePrimes(100000);
    displayResults(primes);
}

// Better approach: Using background threads
public void onCalculateButtonClick(View view) {
    new Thread(() -> {
        List<Integer> primes = calculatePrimes(100000);
        
        // Update UI on the main thread
        runOnUiThread(() -> {
            displayResults(primes);
        });
    }).start();
    
    // Even better: Using structured concurrency
    ExecutorService executor = Executors.newSingleThreadExecutor();
    Handler handler = new Handler(Looper.getMainLooper());
    
    executor.execute(() -> {
        List<Integer> primes = calculatePrimes(100000);
        
        handler.post(() -> {
            displayResults(primes);
        });
    });
}

// Anti-pattern: Inefficient string concatenation in a loop
public String buildReport(List<String> items) {
    String report = "";
    for (String item : items) {
        // Creates a new String object in each iteration
        report = report + item + ", ";
    }
    return report;
}

// Better approach: Using StringBuilder
public String buildReportEfficiently(List<String> items) {
    StringBuilder reportBuilder = new StringBuilder();
    for (String item : items) {
        reportBuilder.append(item).append(", ");
    }
    return reportBuilder.toString();
}

// Anti-pattern: Inefficient string concatenation in JavaScript
function buildReport(items) {
  let report = '';
  for (let i = 0; i < items.length; i++) {
    report = report + items[i] + ', ';
  }
  return report;
}

// Better approach: Using array join
function buildReportEfficiently(items) {
  return items.join(', ');
}

// For more complex concatenation
function buildComplexReport(items) {
  const parts = [];
  for (let i = 0; i < items.length; i++) {
    parts.push(items[i]);
  }
  return parts.join(', ');
}

// Anti-pattern: Recompiling regular expressions in loops
function validateEmails(emails) {
  const validEmails = [];
  
  for (const email of emails) {
    // Regex is recompiled in each iteration
    if (/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/.test(email)) {
      validEmails.push(email);
    }
  }
  
  return validEmails;
}

// Better approach: Compile regex once
function validateEmailsEfficiently(emails) {
  const validEmails = [];
  // Compile regex once
  const emailRegex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
  
  for (const email of emails) {
    if (emailRegex.test(email)) {
      validEmails.push(email);
    }
  }
  
  return validEmails;
}

# Anti-pattern: Recompiling regular expressions in Python
def validate_emails(emails):
    valid_emails = []
    
    for email in emails:
        # Regex is recompiled in each iteration
        if re.match(r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$', email):
            valid_emails.append(email)
            
    return valid_emails

# Better approach: Compile regex once
import re

def validate_emails_efficiently(emails):
    valid_emails = []
    # Compile regex once
    email_regex = re.compile(r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$')
    
    for email in emails:
        if email_regex.match(email):
            valid_emails.append(email)
            
    return valid_emails

// Anti-pattern: Bubble sort (O(n²) complexity)
function bubbleSort(arr) {
  const n = arr.length;
  
  for (let i = 0; i < n; i++) {
    for (let j = 0; j < n - i - 1; j++) {
      if (arr[j] > arr[j + 1]) {
        // Swap elements
        [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
      }
    }
  }
  
  return arr;
}

// Better approach: Using native sort or more efficient algorithms
function efficientSort(arr) {
  // JavaScript's native sort uses an optimized algorithm
  return [...arr].sort((a, b) => a - b);
}

// For custom sorting needs, consider more efficient algorithms
function quickSort(arr) {
  if (arr.length <= 1) {
    return arr;
  }
  
  const pivot = arr[Math.floor(arr.length / 2)];
  const left = arr.filter(x => x < pivot);
  const middle = arr.filter(x => x === pivot);
  const right = arr.filter(x => x > pivot);
  
  return [...quickSort(left), ...middle, ...quickSort(right)];
}

// Anti-pattern: Selection sort (O(n²) complexity)
public void selectionSort(int[] arr) {
    int n = arr.length;
    
    for (int i = 0; i < n - 1; i++) {
        int minIdx = i;
        for (int j = i + 1; j < n; j++) {
            if (arr[j] < arr[minIdx]) {
                minIdx = j;
            }
        }
        
        // Swap elements
        int temp = arr[minIdx];
        arr[minIdx] = arr[i];
        arr[i] = temp;
    }
}

// Better approach: Using built-in sorting
public void efficientSort(int[] arr) {
    // Java's Arrays.sort uses a dual-pivot Quicksort
    Arrays.sort(arr);
}

// For objects or custom comparisons
public void sortObjects(List<Person> people) {
    Collections.sort(people, Comparator.comparing(Person::getAge));
}

// Anti-pattern: Creating unnecessary objects in a loop
public double calculateAverage(int[] values) {
    double sum = 0;
    for (int i = 0; i < values.length; i++) {
        // Creates a new Double object in each iteration
        Double value = Double.valueOf(values[i]);
        sum += value;
    }
    return sum / values.length;
}

// Better approach: Avoiding unnecessary object creation
public double calculateAverageEfficiently(int[] values) {
    double sum = 0;
    for (int i = 0; i < values.length; i++) {
        // Uses primitive types
        sum += values[i];
    }
    return sum / values.length;
}

// Anti-pattern: Creating objects inside a hot loop
function processData(data) {
  let results = [];
  
  for (let i = 0; i < data.length; i++) {
    // Creates a new object in each iteration
    results.push({
      id: data[i].id,
      value: data[i].value,
      processed: true,
      timestamp: new Date()
    });
  }
  
  return results;
}

// Better approach: Minimizing object creation
function processDataEfficiently(data) {
  const now = new Date(); // Create date object once
  let results = [];
  
  for (let i = 0; i < data.length; i++) {
    // Reuse existing properties when possible
    const item = data[i];
    item.processed = true;
    item.timestamp = now;
    results.push(item);
  }
  
  return results;
}

// Anti-pattern: Inefficient collection operations
public boolean containsValue(List<String> list, String value) {
    // Linear search (O(n) complexity)
    for (String item : list) {
        if (item.equals(value)) {
            return true;
        }
    }
    return false;
}

// Better approach: Using appropriate data structures
public boolean containsValueEfficiently(Set<String> set, String value) {
    // O(1) average case complexity with HashSet
    return set.contains(value);
}

// Anti-pattern: Repeatedly checking size in a loop
public void processLargeList(List<String> items) {
    for (int i = 0; i < items.size(); i++) { // items.size() called in each iteration
        processItem(items.get(i));
    }
}

// Better approach: Caching the size
public void processLargeListEfficiently(List<String> items) {
    int size = items.size(); // Calculate size once
    for (int i = 0; i < size; i++) {
        processItem(items.get(i));
    }
}

# Anti-pattern: Inefficient list operations
def find_duplicates(items):
    duplicates = []
    for item in items:
        if items.count(item) > 1 and item not in duplicates:  # O(n) operation in each iteration
            duplicates.append(item)
    return duplicates

# Better approach: Using appropriate data structures
def find_duplicates_efficiently(items):
    seen = set()
    duplicates = set()
    
    for item in items:
        if item in seen:  # O(1) operation
            duplicates.add(item)
        else:
            seen.add(item)
            
    return list(duplicates)

// Anti-pattern: Recursive Fibonacci without memoization
function fibonacci(n) {
  if (n <= 1) return n;
  return fibonacci(n - 1) + fibonacci(n - 2);
}

// Better approach: Using memoization
function fibonacciWithMemoization(n, memo = {}) {
  if (n <= 1) return n;
  
  if (memo[n]) return memo[n];
  
  memo[n] = fibonacciWithMemoization(n - 1, memo) + 
            fibonacciWithMemoization(n - 2, memo);
  
  return memo[n];
}

// Even better: Using iteration
function fibonacciIterative(n) {
  if (n <= 1) return n;
  
  let a = 0, b = 1;
  for (let i = 2; i <= n; i++) {
    const temp = a + b;
    a = b;
    b = temp;
  }
  
  return b;
}

# Anti-pattern: Recursive function without memoization
def factorial(n):
    if n <= 1:
        return 1
    return n * factorial(n - 1)

# Better approach: Using memoization
from functools import lru_cache

@lru_cache(maxsize=None)
def factorial_memoized(n):
    if n <= 1:
        return 1
    return n * factorial_memoized(n - 1)

# Even better: Using iteration
def factorial_iterative(n):
    result = 1
    for i in range(2, n + 1):
        result *= i
    return result

// Anti-pattern: Unnecessary computations in a loop
function processItems(items) {
  const results = [];
  
  for (let i = 0; i < items.length; i++) {
    // Expensive calculation performed for every item
    const taxRate = calculateTaxRate(items[i].country);
    const price = items[i].price;
    const tax = price * taxRate;
    
    results.push({
      item: items[i],
      finalPrice: price + tax
    });
  }
  
  return results;
}

// Better approach: Caching expensive computations
function processItemsEfficiently(items) {
  const results = [];
  const taxRateCache = {}; // Cache for tax rates
  
  for (let i = 0; i < items.length; i++) {
    const country = items[i].country;
    const price = items[i].price;
    
    // Use cached value if available
    if (!taxRateCache[country]) {
      taxRateCache[country] = calculateTaxRate(country);
    }
    
    const taxRate = taxRateCache[country];
    const tax = price * taxRate;
    
    results.push({
      item: items[i],
      finalPrice: price + tax
    });
  }
  
  return results;
}

// Anti-pattern: Unnecessary computations in rendering
public class ProductView extends View {
    private List<Product> products;
    
    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        
        // Expensive calculations in the draw method
        double total = 0;
        for (Product product : products) {
            total += product.getPrice() * calculateTaxRate(product.getCountry());
            // Draw product...
        }
        
        // Draw total...
    }
}

// Better approach: Performing calculations only when needed
public class ProductView extends View {
    private List<Product> products;
    private double cachedTotal;
    private boolean totalNeedsRecalculation = true;
    
    public void setProducts(List<Product> products) {
        this.products = products;
        totalNeedsRecalculation = true;
        invalidate();
    }
    
    private double calculateTotal() {
        if (totalNeedsRecalculation) {
            double total = 0;
            Map<String, Double> taxRateCache = new HashMap<>();
            
            for (Product product : products) {
                String country = product.getCountry();
                
                // Use cached tax rate if available
                if (!taxRateCache.containsKey(country)) {
                    taxRateCache.put(country, calculateTaxRate(country));
                }
                
                total += product.getPrice() * taxRateCache.get(country);
            }
            
            cachedTotal = total;
            totalNeedsRecalculation = false;
        }
        
        return cachedTotal;
    }
    
    @Override
    protected void onDraw(Canvas canvas) {
        super.onDraw(canvas);
        
        // Draw products...
        
        // Use pre-calculated total
        double total = calculateTotal();
        // Draw total...
    }
}

// Anti-pattern: Inefficient JSON handling
function processLargeJsonResponse(jsonString) {
  // Parse entire JSON at once
  const data = JSON.parse(jsonString);
  
  // Process only a small portion of the data
  return data.users.filter(user => user.active).map(user => user.name);
}

// Better approach: Using streaming JSON parser for large data
function processLargeJsonResponseEfficiently(jsonString) {
  const names = [];
  
  // Using a streaming JSON parser like Oboe.js
  oboe(jsonString)
    .node('users[*]', user => {
      if (user.active) {
        names.push(user.name);
      }
      // Return oboe.drop to free memory
      return oboe.drop;
    });
  
  return names;
}

// Anti-pattern: Inefficient JSON parsing in Java
public List<String> getActiveUserNames(String jsonString) throws Exception {
    // Parse entire JSON at once
    ObjectMapper mapper = new ObjectMapper();
    JsonNode rootNode = mapper.readTree(jsonString);
    
    List<String> names = new ArrayList<>();
    JsonNode usersNode = rootNode.get("users");
    
    for (JsonNode userNode : usersNode) {
        if (userNode.get("active").asBoolean()) {
            names.add(userNode.get("name").asText());
        }
    }
    
    return names;
}

// Better approach: Using streaming JSON parser
public List<String> getActiveUserNamesEfficiently(String jsonString) throws Exception {
    List<String> names = new ArrayList<>();
    
    JsonFactory factory = new JsonFactory();
    JsonParser parser = factory.createParser(jsonString);
    
    // Find the users array
    while (parser.nextToken() != JsonToken.END_OBJECT) {
        String fieldName = parser.getCurrentName();
        if ("users".equals(fieldName)) {
            // Enter the array
            parser.nextToken();
            // Iterate through array elements
            while (parser.nextToken() != JsonToken.END_ARRAY) {
                boolean isActive = false;
                String name = null;
                
                // Parse user object
                while (parser.nextToken() != JsonToken.END_OBJECT) {
                    String userField = parser.getCurrentName();
                    parser.nextToken();
                    
                    if ("active".equals(userField)) {
                        isActive = parser.getBooleanValue();
                    } else if ("name".equals(userField)) {
                        name = parser.getText();
                    }
                }
                
                if (isActive && name != null) {
                    names.add(name);
                }
            }
            break;
        }
    }
    
    parser.close();
    return names;
}

CPU-Intensive Operations Prevention Checklist:

1. Thread Management
   - Move CPU-intensive operations off the main/UI thread
   - Use background threads, workers, or async operations
   - Implement proper thread pooling
   - Consider using non-blocking I/O
   - Avoid thread contention and excessive context switching

2. Algorithm Optimization
   - Choose algorithms with appropriate time complexity
   - Use memoization for expensive recursive functions
   - Implement caching for repetitive calculations
   - Consider space-time tradeoffs
   - Use specialized algorithms for specific use cases

3. Data Structure Selection
   - Choose appropriate data structures for operations
   - Be aware of the performance characteristics of collections
   - Use specialized data structures for specific use cases
   - Consider memory usage vs. access time tradeoffs
   - Pre-allocate collections when size is known

4. String and Text Processing
   - Use efficient string builders for concatenation
   - Compile regular expressions once, outside of loops
   - Consider using specialized text processing libraries
   - Be cautious with complex regular expressions
   - Use string interning for frequently used strings

5. Object Creation and Memory Management
   - Minimize object creation in hot code paths
   - Reuse objects when appropriate
   - Consider object pooling for expensive objects
   - Use value types or primitives when possible
   - Be aware of boxing/unboxing overhead

6. Parsing and Serialization
   - Use streaming parsers for large documents
   - Consider binary formats for better performance
   - Implement partial parsing when appropriate
   - Reuse parser instances when possible
   - Consider schema validation for structured data

7. Loop Optimization
   - Move invariant calculations outside loops
   - Consider loop unrolling for small, critical loops
   - Use appropriate loop constructs
   - Consider parallelizing loops for large datasets
   - Minimize function calls inside loops

8. Measurement and Profiling
   - Use profiling tools to identify bottlenecks
   - Establish performance baselines and budgets
   - Measure performance with realistic data volumes
   - Focus optimization efforts on hot code paths
   - Validate optimizations with benchmarks