An often used memoization idiom causes problems in Ruby.

w.rb

# Run this example with $ ruby -W w.rb

class Gallery
  attr_reader :disabled

  def initialize(disabled:)
    @disabled = disabled
  end

  def images
    @images ||= []
  end

  def enabled?
    @enabled ||= !disabled
  end
end

class Camera
  attr_reader :disabled

  def initialize(disabled:)
    @disabled = disabled
  end

  def images
    if defined?(@images)
      @images
    else
      @images = []
    end
  end

  def enabled?
    if defined?(@enabled)
      @enabled
    else
      @enabled != disabled
    end
  end
end

require 'minitest/autorun'

class Test < Minitest::Test
  def test_gallery_enabled
    assert Gallery.new(disabled: false).enabled?
  end

  def test_gallery_disabled
    refute Gallery.new(disabled: true).enabled?
  end

  def test_camera_enabled
    assert Camera.new(disabled: false).enabled?
  end

  def test_camera_disabled
    refute Camera.new(disabled: true).enabled?
  end
end

why.md

An often used memoization idiom causes warnings in Ruby

These warnings are there to help you find typos in your code; in this case it's an instance variable. When you write @diabled you will see a warning about it not being initialized, which helps you track down weird bugs.

Using the idiom is also not possible for boolean values because @a ||= false will always re-evaluate the right part of the expression. Remember that it's actually:

@a = @a || false

Now @a becomes false. So in the second iteration of this statement you evaluate this

@a = false || false

Now assume that the right side part of the expression takes 20 hours to compute.

Not sure if this is the "bug" you mentioned, but I'd just like to point out this common misconception in Ruby. This:

@a ||= false

actually expands to this:

@a || @a = false

The end result is the same, however.