Handle the Unexpected: Mastering Edge Cases in Programming

What is "edge cases"?

When you're coding, you might run into situations that your program doesn't handle well. These are called "edge cases".

Here's how you can correct your code when you encounter one:

• Identify the problem: First, figure out exactly what's going wrong. What input is causing your code to break or give unexpected results?
• Reproduce the issue: Create a test case that consistently shows the problem. This helps you confirm when you've fixed it.
• Analyze your code: Look closely at the part of your code that's causing trouble. What assumptions did you make that aren't true for this edge case?
• Plan your solution: Think about how you can modify your code to handle this special situation without breaking the normal cases.
• Implement the fix: Make the necessary changes to your code.
• Test thoroughly: Make sure your fix works for the edge case AND that it didn't break anything else.

Example 1

Imagine you have a blog app where users can create posts. You want to display the most recent post's title on the homepage. Your initial code might look like this:

class HomeController < ApplicationController
  def index
    @latest_post_title = Post.order(created_at: :desc).first.title
  end
end

This works fine as long as there's at least one post. But what if there are no posts yet? This is an edge case that will cause an error.

To fix it, you could modify the code like this:

class HomeController < ApplicationController
  def index
    @latest_post_title = Post.order(created_at: :desc).first&.title || "No posts yet"
  end
end

Now, if there are no posts, instead of crashing, your app will display "No posts yet" on the homepage.

Example 2: Division function

Without edge case handling:

def divide(numerator, denominator)
  numerator / denominator
end

Issue: This will raise a ZeroDivisionError if denominator is zero.

With edge case handling:

def safe_divide(numerator, denominator)
  return 0 if denominator.zero?
  numerator / denominator
end

Solution: We check if the denominator is zero before performing the division, returning 0 in that case.

Example 3: Getting page number

Without edge case handling:

def get_page_number(params)
  params[:page].to_i
end

Issue: This could return 0 or negative numbers, which aren't valid page numbers.

With edge case handling:

def get_page_number(params)
  page = params[:page].to_i
  page.positive? ? page : 1
end

Example 4: Date range filter

Without edge case handling:

def date_range_filter(start_date, end_date)
  start_date..end_date
end

Issue: This doesn't handle nil inputs or ensure start_date is before end_date.

With edge case handling:

def date_range_filter(start_date, end_date)
  start_date = start_date.presence || 30.days.ago.to_date
  end_date = end_date.presence || Date.today
  [start_date, end_date].min..[start_date, end_date].max
end

Solution: We provide default values for nil inputs and ensure the range is always from the earlier date to the later date.

Common edge cases to check

• Null or nil values: Ensure code handles absent data.
• Empty collections: Test behavior with zero items.
• Boundary values: Check limits (e.g., min/max integers).
• Invalid input: Handle unexpected data types or formats.
• Duplicates: Ensure uniqueness where required.
• Overflow/underflow: Prevent arithmetic errors.
• Concurrent access: Handle race conditions in multi-threaded environments.
• Resource constraints: Manage memory/disk space limits.
• Network issues: Handle timeouts and disconnections.
• Permissions: Test with different user access levels.
• Large datasets: Ensure performance with significant data volumes.
• Internationalization: Test with different languages and character sets.
• Cross-platform compatibility: Verify on various operating systems.
• Time-related issues: Consider time zones, leap years, daylight saving.
• Floating-point precision: Account for rounding errors in calculations.