The document discusses Rails best practices for developing applications efficiently. It recommends: 1. Using eager loading to prevent N+1 queries which loads associated objects efficiently. 2. Rescuing only StandardError instead of all exceptions to avoid catching errors like SyntaxError. 3. Using query attributes instead of present?/blank? methods to check if attributes exist. 4. Caching with instance variables or memoization to avoid duplicate database queries and calculations. 5. Using find_each/find_in_batches for large data queries to load data in batches instead of all at once.

1. Rails Best Practices
By
Nitesh Varma
Developer
Allerin Tech Pvt Ltd

2. What is best practices?
• Best practices are using approaches that not
only delivers superior results but also
consider feasibility and ongoing development
of the approach.

3. Need?
• With the fast pace of today’s agile development
industries, we know how important it is to complete a
project on time.
• We also recognize the importance of other factors
such as flexibility, readability & most important
performance of the application.
• Even experienced developers some time do not
consider above points at the initial stage of application
launch, but later it start deteriorating the performance
when the data’s in the application grows exponentially
and enhancement needs to be done in existing
application.

4. • Below are the some best practices in Rails ,
which should have to be considered at the
time of development when using Rails
framework.

5. Use Eager Loading (Prevent N + 1
query)
• Most of the time new Rails developers do not
use eager loading of objects in Rails.
• Eager Loading is highly recommended at the
time of development in Rails.
• It mainly resolved the common issues like N +
1 queries.
• We can detect the N + 1 queries issues by
using gem ‘Bullet’ in development
environment.

8. Don’t Rescue Exception, Rescue
Standard Error
Explicitly rescuing Exception will also rescue code
errors such as SyntaxError, LoadError etc.
Consider below begin-rescue syntax

9. If we do not use Exception type qualifier, then
Ruby will catch only StandardError, which is
probably what we want from begin-rescue:

10. Use query attribute
We always check if ActiveRecord’s attributes exist or not by nil?,
blank? or present? ? Rails provides a cleaner way for this by
query attribute.
Suppose locked is boolean value of users table.
General:

11. The query attribute is almost the same as the present? method
call on attribute, or the opposite of blank? method call. Each
attribute of ActiveRecord’s model has a query method, so we
don’t need to use the present? or blank? for ActiveRecord’s
attributes.
Re-factored:

12. Caching with instance variable or Use
memoization

13. How can we avoid the duplicated db query and duplicated
calculation? We can use following methods.

14. We can also do this with memoize

15. Use batched finder for large data query
Suppose you have social network website containing millions
of user and you needs to send daily notification to them
morning.

16. Using find_each, the application only finds 1000 users once, yield them, then handle
the next 1000 users, until the last 1000 users. That means the application will only
load 1000 user objects into memory each time.
1000 is the default batch size, if we want to change batch_size we can use :batch_size
option to change it.

17. find_in_batches is similar to find_each except that it yields the array of objects

18. Replace instance variable with local variable
Partial is a reusable view template, In partial view, we can use
the instance variable directly, but it may be confused and make
it hard to reuse anywhere (variable leakage), because we don’t
know exactly which instance variable can be used, so we can
use the local variable in partial which will be explicitly
assignment at the time of render.

20. Questions?

21. Thank you