Memoization is an optimization technique that caches the results of expensive method calls to avoid repeating the same computation multiple times. The document discusses memoizing the current_user method in Ruby by using the ||= conditional assignment operator to assign the result of User.find(session[:user_id]) to the @current_user instance variable only if it is nil. This avoids duplicate database queries when current_user is called multiple times. The document also provides examples of when memoization should and should not be used, such as memoizing expensive calculations that do not change but not calculations that take parameters or can easily change.

1. Basic memoization
in Ruby
Ombu Labs, April 2015

2. “Memoization is an optimization
technique where you cache the
results of expensive method
calls.”
http://nithinbekal.com/posts/ruby-memoization/

3. Conditional assignment
operator
a ||= b

4. irb(main):001:0> a = 1
=> 1
irb(main):002:0> a ||= 2
=> 1
Not assigned, because a was already set to 1
irb(main):003:0> a = nil
=> nil
irb(main):004:0> a ||= 2
=> 2
Assigned, because a was nil

5. a ||= b == a || a = b

6. Without memoization

7. def current_user
User.find(session[:user_id])
end

9. With memoization

10. def current_user
@current_user ||= User.find(session[:user_id])
end

12. When to memoize?

13. • Duplicate database calls
• Expensive calculations
• Calculations that do not change

14. When NOT to memoize?

15. • Some methods that take parameters *
• Calculations that can easily change
* unless you memoize a Hash object

16. 2.1.2 :001 > def say_hi(name)
2.1.2 :002?> @greeting ||= "Hello #{name}!"
2.1.2 :003?> end
=> :say_hi
2.1.2 :004 > say_hi("John")
=> "Hello John!"
2.1.2 :005 > say_hi("You")
=> "Hello John!"

17. Real use case

18. CACHE (0.0ms) SELECT "groups".* FROM "groups" WHERE "groups"."id" = $1 LIMIT 1 [["id", 3]]
CACHE (0.1ms) SELECT "groups".* FROM "groups" WHERE "groups"."id" = $1 LIMIT 1 [["id", 3]]
CACHE (0.0ms) SELECT "groups".* FROM "groups" WHERE "groups"."id" = $1 LIMIT 1 [["id", 3]]
CACHE (0.0ms) SELECT "groups".* FROM "groups" WHERE "groups"."id" = $1 LIMIT 1 [["id", 3]]
CACHE (0.0ms) SELECT "groups".* FROM "groups" WHERE "groups"."id" = $1 LIMIT 1 [["id", 3]]
… (around 100 calls)

19. By applying the memoization pattern,
the cached query count was reduced
from around 100 to less than 40

21. “Those cache calls mean Rails is returning the
cached result of the SQL query, but it doesn’t
include the cost of building the User object.”
“And because Rails hides the cost of object
creation these queries cost more than the 0.0ms
and 0.1ms reported!”
http://gavinmiller.io/2013/basics-of-ruby-memoization/

22. THANK YOU!
questions?