Memoization is an optimization technique that can significantly improve the result of expensive computation by caching the data. This technique works perfectly for Ruby on Rails applications. It includes caching the output of complex computing methods and returning it when the same input is entered again.

The **||=** operator is a frequently used technique in Ruby memoization implementation.

Performance optimization is essential for Ruby on Rails applications, particularly when handling costly computations and a high volume of database queries. Memoization is a strategy that, by caching the outcomes of costly operations, can greatly increase performance. Using the **||=** operator is one of the easiest ways to do memoization in Ruby.

**Example**

Let's take an example for calculating the factorial of a number. Factorial is denoted as **(!n)**. It is calculated as the product of all positive integers less than or equal to **n**.

```
class Factorial
def calculate(n)
return 1 if n<=1
n * calculate(n - 1)
end
end
fact = Factorial.new
puts fact.calculate(5)
#output = 120
```

This is the example for calculating the factorial of a number. In this each call to the calculate method leads to unnecessary calculation.

**Challenges**

The primary difficulty in this case is doing the same calculations again, which could cause impactful performance issues for greater values of **n**.

Memoization is an approach where you actually save the result of a method that is being called repeatedly and then reuse the result of that stored method when that method is called again. The ** ‘||=’** operator in Ruby provides a simple way to implement memoization.

**‘||=’** this operator is shorthand for **“or equals”.** It assigns a value to a variable only if that variable is nil or false.

**Example**

**With Memoization**

```
class Factorial
def initialize
@value = {}
end
def calculate(n)
return 1 if n <= 1
if @value[n]
puts "Returning from memoized value for #{n}!"
return @value[n]
end
puts "Calculating factorial for #{n}"
@value[n] = n * calculate(n - 1)
end
end
fact = Factorial.new
puts fact.calculate(5)
#output
puts fact.calculate(5)
Calculating factorial for 5
Calculating factorial for 4
Calculating factorial for 3
Calculating factorial for 2
120
puts fact.calculate(7)
Calculating factorial for 7
Calculating factorial for 6
Returning from memoized value for 5!
5040
puts fact.calculate(5)
Returning from memoized value for 5!
120
puts fact.calculate(3)
Returning from memoized value for 3!
6
```

In this example, the calculate method checks if the factorial for the given number is already present or not in @value hash, if present then returns the prints and return value. If you first calculate 5! Then 7! Then memoization will use 5! Result for calculation, which is more efficient.

The above example prints the result with a memoized value.

**Suggested reads-** Strategies for Updating JSON Columns in Ruby on Rails

- Use memoization for the methods that do complex computation or database queries and that function is being called frequently with the same input or slight change in the input. For instance, operations involving complex calculations, database queries, or API calls can benefit greatly from memoization.
- Ensure that the methods return the same result for the same inputs.
- Memoization stores the results in the memory. Which can lead to high memory usage if not managed properly. If a method has multiple possible inputs, then ensure that cache results do not take excessive memory. Consider limiting cache size.
- Memoization works best when the input is simple and immutable.
- Memoize at the lowest possible level of abstraction where the expensive operation occurs. Memoizing high-level methods might cache more data than necessary, leading to inefficiency.
- Document why and where memoization is being used in your code. This helps other developers understand the purpose and potential pitfalls, like cache invalidation scenarios.

Memoization with the **‘||=’ ** operator is a simple and powerful technique to optimize the performance of your applications. By caching the results of expensive operations, you can significantly reduce the computational overhead and improve the efficiency of your application.

Backend Developer with 3+years of experience with Ruby on Rails. Specialising in backend optimisation, API development, and database. Enthusiastic about developing scalable, effective solutions.

Sep 16, 2024 • 5 min read

Redirection Loops: A Beginner’s Guide

Ever clicked a link only to find your browser stuck in an endless loop? Welcome to the world of redirection loops. These pesky web gremlins can frustrate users and harm your site's performance. In this beginner's guide, we'll...

Sep 16, 2024 • 5 min read

From Razorpay To Global: Our Payment Gateway Journey

When we initiated our project, our vision was clear: create an application tailored for the Indian audience. Naturally, we chose RazorPay as our payment gateway, given its popularity in India. Based on our initial target audi...

Sep 3, 2024 • 4 min read

Why Do React Native & Flutter Outperform Kotlin & Swift?

As the mobile app development landscape continues to evolve, businesses are faced with a daunting decision: should they stick with native languages like Kotlin and Swift, or take the hybrid route with React Native and Flutter...