Why caching improves response times in Ruby on Rails - See It in Action

Why caching improves response times

📖 Scenario: You are building a simple Rails web app that shows a list of popular books. Each time a user visits the page, the app fetches the book data from a slow external source. To make the page load faster, you want to use caching.

🎯 Goal: Build a Rails controller that caches the list of books so that repeated visits load the page faster by avoiding repeated slow data fetching.

📋 What You'll Learn

Create a controller action that fetches book data

Add a cache key variable to control caching

Use Rails caching to store and retrieve the book list

Render the cached book list in the response

💡 Why This Matters

🌍 Real World

Caching is used in web apps to speed up response times by saving results of slow operations like database queries or API calls.

💼 Career

Understanding caching is important for backend developers to improve app performance and user experience.

1

Set up the books data method

In the BooksController, create a method called fetch_books that returns an array of these exact book titles: ["The Hobbit", "1984", "Pride and Prejudice"].

Ruby on Rails

class BooksController < ApplicationController
  # Create fetch_books method returning the exact array
  # Your code here
end

Hint

Define a method named fetch_books inside BooksController that returns the array exactly as shown.

2

Add a cache key variable

Inside BooksController, add a private method called cache_key that returns the string "books_list_v1".

Ruby on Rails

class BooksController < ApplicationController
  def fetch_books
    ["The Hobbit", "1984", "Pride and Prejudice"]
  end

  # Add private cache_key method returning "books_list_v1"
  # Your code here
end

Hint

Create a private method named cache_key that returns the string exactly as shown.

3

Use Rails caching to store and fetch books

Add an action called index in BooksController that uses Rails.cache.fetch(cache_key) to store or retrieve the books by calling fetch_books. Assign the result to @books.

Ruby on Rails

class BooksController < ApplicationController
  def fetch_books
    ["The Hobbit", "1984", "Pride and Prejudice"]
  end

  def index
    # Use Rails.cache.fetch with cache_key to assign @books
    # Your code here
  end

  private

  def cache_key
    "books_list_v1"
  end
end

Hint

Define index method that sets @books using Rails.cache.fetch(cache_key) with a block calling fetch_books.

4

Render the cached books list

In the index action, add a line to render the @books array as JSON using render json: @books.

Ruby on Rails

class BooksController < ApplicationController
  def fetch_books
    ["The Hobbit", "1984", "Pride and Prejudice"]
  end

  def index
    @books = Rails.cache.fetch(cache_key) do
      fetch_books
    end
    # Render @books as JSON
    # Your code here
  end

  private

  def cache_key
    "books_list_v1"
  end
end

Hint

Add render json: @books inside the index method to send the cached books as JSON response.

Practice

1. Why does caching improve response times in a Rails application?

easy

A. Because it stores precomputed data to avoid repeating slow operations

B. Because it increases the size of the database

C. Because it disables user requests temporarily

D. Because it deletes old data automatically

Solution

1. Step 1: Understand what caching does

   Caching saves results of expensive operations so they don't have to run again.

2. Step 2: Connect caching to response speed

   By reusing stored data, the app responds faster because it skips slow work.

3. Final Answer:

   Because it stores precomputed data to avoid repeating slow operations -> Option A

4. Quick Check:

   Caching speeds response by storing data [OK]

Hint: Caching saves time by reusing data, not recalculating it [OK]

Common Mistakes:

• Thinking caching increases database size
• Believing caching blocks user requests
• Assuming caching deletes data automatically

2. Which of the following is the correct way to write a cache fetch block in Rails?

easy

A. Rails.cache.get('key') { expensive_operation }

B. Rails.cache.fetch('key') { expensive_operation }

C. Rails.cache.store('key', expensive_operation)

D. Rails.cache.save('key') { expensive_operation }

Solution

1. Step 1: Recall Rails caching syntax

   The correct method to fetch or store cached data with a block is fetch.

2. Step 2: Verify method names

   get, store, and save are not valid Rails cache methods for this pattern.

3. Final Answer:

   Rails.cache.fetch('key') { expensive_operation } -> Option B

4. Quick Check:

   Use fetch with block to cache [OK]

Hint: Remember: fetch reads or writes cache with a block [OK]

Common Mistakes:

• Using get instead of fetch
• Trying to store with a block incorrectly
• Confusing save with fetch

3. Given this Rails code snippet, what will be the output?

count = 0
result = Rails.cache.fetch('count_key') do
  count += 1
end
puts result
result = Rails.cache.fetch('count_key') do
  count += 1
end
puts result

medium

A. 0 and 1

B. 1 and 2

C. 1 and 1

D. 2 and 2

Solution

1. Step 1: Analyze the first fetch call

   The block runs because cache is empty, so count increments from 0 to 1, and 1 is stored and printed.

2. Step 2: Analyze the second fetch call

   The cache has 'count_key', so the block does not run; cached value 1 is returned and printed again.

3. Final Answer:

   1 and 1 -> Option C

4. Quick Check:

   Cache returns stored value, block skipped second time [OK]

Hint: Cache block runs once; later calls return stored value [OK]

Common Mistakes:

• Assuming block runs every time
• Thinking count increments twice
• Confusing initial count value

4. You added caching to a Rails app, but the response time did not improve. What is the most likely cause?

medium

A. The cache expiration time is set too long

B. The cache store is set to memory_store

C. The cache block returns a static value

D. The cache key changes every request, so cache is never reused

Solution

1. Step 1: Understand caching depends on cache keys

   If the key changes every request, the cache never hits and always recomputes.

2. Step 2: Evaluate other options

   Memory store is fast and good for caching; static values and long expiration do not prevent caching benefits.

3. Final Answer:

   The cache key changes every request, so cache is never reused -> Option D

4. Quick Check:

   Cache key consistency is crucial for reuse [OK]

Hint: Check if cache keys stay the same to reuse data [OK]

Common Mistakes:

• Blaming cache store type incorrectly
• Thinking static values hurt caching
• Assuming long expiration slows response

5. You want to cache a user's profile page in Rails but ensure it updates when the user changes their name. Which caching strategy best balances speed and freshness?

hard

A. Cache the page with a key including the user's updated_at timestamp

B. Cache the page forever without expiration

C. Do not cache the page at all to always show fresh data

D. Cache the page but clear the entire cache when any user updates

Solution

1. Step 1: Identify need for freshness and caching

   We want fast responses but also updated content when user changes name.

2. Step 2: Use cache key with updated_at timestamp

   Including updated_at in the cache key ensures cache refreshes only when user data changes.

3. Step 3: Evaluate other options

   Caching forever risks stale data; no caching is slow; clearing entire cache is inefficient.

4. Final Answer:

   Cache the page with a key including the user's updated_at timestamp -> Option A

5. Quick Check:

   Cache key with timestamp balances speed and freshness [OK]

Hint: Use timestamps in cache keys to auto-refresh stale data [OK]

Common Mistakes:

• Caching forever causing stale pages
• Not caching and losing speed benefits
• Clearing whole cache wastes resources