{"id":988,"date":"2021-01-01T10:44:00","date_gmt":"2021-01-01T08:44:00","guid":{"rendered":"https:\/\/arc.dev\/developer-blog\/?p=988"},"modified":"2024-04-17T11:31:06","modified_gmt":"2024-04-17T03:31:06","slug":"ruby-on-rails-interview-questions","status":"publish","type":"post","link":"https:\/\/arc.dev\/talent-blog\/ruby-on-rails-interview-questions\/","title":{"rendered":"11 Ruby on Rails Interview Questions and Answers"},"content":{"rendered":"\n

Looking to hire a Ruby on Rails (RoR) developer? You\u2019ll want to start by putting together an interview guide that can thoroughly test your candidate\u2019s technical knowledge.<\/p>\n\n\n\n

Experienced senior developers at Arc collaborated on this list of Ruby on Rails interview questions to help set the stage for your successful RoR technical interviews.<\/p>\n\n\n\n

Let\u2019s get started!\u00a0<\/p>\n\n\n\n

Looking to hire the best remote developers? Arc can help you:<\/em><\/p>\n\n\n\n

\u26a1\ufe0f Get instant candidate matches without searching
\u26a1\ufe0f Identify top applicants from our network of 350,000+
\u26a1\ufe0f Hire 4x faster with vetted candidates (qualified and interview-ready)<\/em><\/p>\n\n\n\n

Try Arc to hire top developers now \u2192<\/strong><\/em><\/a><\/p>\n\n\n\n

1. Consider the scenario below and answer the following questions:<\/h2>\n\n\n\n

The product team has a great new feature they want to add to your Ruby on Rails application: they want every model in the system to be able to retain special user notes. You realize that there will be a collection of forms and model code that will be duplicated in the dozen<\/em><\/em> ActiveRecord<\/code>\u00a0models already in your application.<\/em><\/p>\n\n\n\n

What are some strategies you can employ for reducing duplication and bloated Active Record models? What are the pros\/cons of each strategy?<\/strong><\/p>\n\n\n\n

Because Ruby on Rails is an MVC framework, it can become tempting to try and fit everything into the Model or the Controller. Ruby on Rails is a powerful framework that provides many different mechanisms for describing our application and keeping our models and controllers nice and tidy.<\/p>\n\n\n\n

Below are two ways of reducing fat models. They illustrate different levels of shared understanding between the extracted functionality and the model in question.<\/p>\n\n\n\n

1. Use ActiveSupport::Concern<\/code><\/h3>\n\n\n\n

If the code really belongs in the model (because it relies on ActiveRecord helpers), but there is a coherent grouping of methods, a concern might be worth implementing. For example, many models in a system could enable a user to create a note on a number of models:<\/p>\n\n\n\n

require<\/strong> 'active_support\/concern'\n\nmodule<\/strong> Concerns::Noteable<\/strong>\n  extend ActiveSupport::Concern\n\n  included do<\/strong>\n    has_many :notes, as: :noteable, dependent: :destroy\n  end<\/strong>\n\n  def<\/strong> has_simple_notes?<\/strong>\n    notes.not_reminders_or_todos.any?\n  end<\/strong>\n\n  def<\/strong> has_to_do_notes?<\/strong>\n    notes.to_dos.any?\n  end<\/strong>\n\n  def<\/strong> has_reminder_notes?<\/strong>\n    notes.reminders.any?\n  end<\/strong>\n  ...\nend<\/strong><\/code><\/pre>\n\n\n\n
The Concern can then be applied like so:<\/p>\n\n\n\n
class<\/strong> Language<\/strong> < ActiveRecord::Base\n  include<\/strong> TryFind\n  include<\/strong> Concerns::Noteable\nend<\/strong><\/code><\/pre>\n\n\n\n
Pros:<\/strong>
This is a great way of testing a cohesive piece of functionality and making it clear to other developers that these methods belong together. Unit tests can also operate on a test double or a stub, which will keep functionality as decoupled from the remaining model implementation as possible.<\/p>\n\n\n\n
Cons:<\/strong>
ActiveSupport::Concerns<\/code> can be a bit controversial. When they are over-used, the model becomes peppered in multiple files and it\u2019s possible for multiple concerns to have clashing implementations. A concern is still fundamentally coupled to Rails.<\/p>\n\n\n\n
2. Delegate<\/h3>\n\n\n\n
Depending on the source of the bloat, sometimes it makes better sense to delegate to a service class. 10 lines of validation code can be wrapped up in a custom validator and tucked away in app\/validators. Transformation of form parameters can be placed in a custom form under app\/forms. If you have custom business logic, it may be prudent to keep it in a lib\/ folder until it\u2019s well defined.<\/p>\n\n\n\n
The beauty of delegation is that the service classes will have no knowledge of the business domain and can be safely refactored and tested without any knowledge of the models.<\/p>\n\n\n\n
Pros:<\/strong>
This approach is elegant and builds a custom library on top of what Ruby on Rails provides out of the box.<\/p>\n\n\n\n
Cons:<\/strong>
If the underlying APIs change, your code will likely need to be updated to match. Instead of coupling to your model layer, you\u2019ve now coupled yourself to either Ruby on Rails or a third-party library.<\/p>\n\n\n\n
Conclusion<\/strong>\u00a0:
This question helps demonstrate two critical skills every Ruby developer needs to develop: how to handle complexity from emerging requirements and how to decide the most appropriate refactoring.<\/p>\n\n\n\n
By working through different refactoring strategies, you can explore a candidate\u2019s problem-solving skills, their overall familiarity with Ruby on Rails, and their knowledge of MVC. Knowing what code is specific to the application and what can be generalized into a completely decoupled piece of functionality is important.<\/p>\n\n\n\n
2. Given an array [1,2,34,5,6,7,8,9]<\/code>, sum it up using a method:<\/h2>\n\n\n\n
def<\/strong> sum<\/strong>(array)\n  return<\/strong> array.inject(:+)\nend<\/strong><\/code><\/pre>\n\n\n\n
The summation of an array is one of the most fundamental concepts in programming, and there are a lot of methods to achieve it, such as iterating the array and summing the numbers. In Ruby, it\u2019s neat to know there is a method called\u00a0inject<\/code>, because it\u2019s so powerful yet simple.<\/p>\n\n\n\n
3. What is metaprogramming?<\/h2>\n\n\n\n
Ruby developers should know what metaprogramming is because it is widely used, especially in popular frameworks such as Rails, Sinatra, and Padrino. By using metaprogramming, you can reduce duplicate code. However, the downside is that it increases the complexity of the code in the long run.<\/p>\n\n\n\n
Here\u2019s an example of metaprogramming in Ruby:<\/p>\n\n\n\n
A user can have a lot of roles, and you want to check the authorization.<\/p>\n\n\n\n
Normal scenario:<\/strong><\/p>\n\n\n\n
def<\/strong> admin?<\/strong>\n     role ==  'admin'\nend<\/strong>\n\ndef<\/strong> marketer?<\/strong>\n    role == 'marketer'\nend<\/strong>\n\ndef<\/strong> sales?<\/strong>\n   role == 'sales'\nend<\/strong><\/code><\/pre>\n\n\n\n
Metaprogramming:<\/strong><\/p>\n\n\n\n
['admin', 'marketer', 'sales'].each do<\/strong> |user_role|\n    define_method \"#{user_role}?\" do<\/strong>\n        role == user_role\n    end<\/strong>\nend<\/strong><\/code><\/pre>\n\n\n\n
4. Give the output of the stated class implementation:<\/h2>\n\n\n\n
Given this Human<\/code> class implementation:<\/em><\/p>\n\n\n\n
class<\/strong> Human<\/strong>\n\n    def<\/strong> talk<\/strong>\n        puts \"I\u2019m talking\"\n    end<\/strong>\n\n     private\n\n     def<\/strong> whisper<\/strong>\n          puts \"I\u2019m whispering\"\n     end<\/strong>\nend<\/strong><\/code><\/pre>\n\n\n\n
What\u2019s the output of:<\/strong><\/p>\n\n\n\n
  1. Human.new.talk<\/code><\/li>
  2. Human.new.whisper<\/code><\/li>
  3. Human.new.send(:talk)<\/code><\/li>
  4. Human.new.send(:whisper)<\/code><\/li><\/ol>\n\n\n\n
    \n\n\n\n
    1. I\u2019m talking<\/code><\/li>
    2. NoMethodError: private method \u2018whisper\u2019 called for #<Human:0x007fd97b292d48><\/code><\/li>
    3. I\u2019m talking<\/code><\/li>
    4. I\u2019m whispering<\/code><\/li><\/ol>\n\n\n\n
      To explain, the class object Human.new.talk<\/code> is calling an instance method, so it works perfectly. The talk<\/code> method is a public method and can be called by everyone.<\/p>\n\n\n\n
      The class object Human.new.whisper<\/code> is trying to access a private method, which it is not allowed to. Private and Protected methods are not accessible from outside. They are only used internally. This is an object-oriented design and can be used to structure the code, which the implementation is not supposed to expose to consumer object.<\/p>\n\n\n\n
      Finally, Human.new.send(:talk)<\/code> sends a bypass control check to the method so it can be called without raising an error. Same goes to Human.new.send(:whisper)<\/code>.<\/p>\n\n\n\n
      5. Write code that splits a given array of integers into two arrays; the first containing odd numbers and second containing even numbers.<\/h2>\n\n\n\n
      %i|select reject|.map { |m| array.partition(&odd?)}<\/code><\/pre>\n\n\n\n
      or<\/p>\n\n\n\n
      array.each_with_object({odd:[], even:[]}) do<\/strong> |elem, memo|\n  memo[elem.odd? ? :odd : :even] << elem\nend<\/strong> # inject for ruby < 2.0 is fine as well<\/em><\/code><\/pre>\n\n\n\n
      The straightforward approach would be to call array.select to store odds and then array.reject to store evens. There is nothing wrong with this, except it violates DRY principle:<\/p>\n\n\n\n
      odds = array.select &:odd?\nevens = array.reject &:odd?<\/code><\/pre>\n\n\n\n
      Future modification of this code might accidentally change the only one line from the above pair, breaking consistency. It is not likely the case for this particular example, but DRY usually works for future use.<\/p>\n\n\n\n
      One might notice that the latter example does one iteration through an array, while the former is still iterating the array twice, once for each method. In most cases, the performance penalty is not significant, but it should be taken into consideration when dealing with huge arrays.<\/p>\n\n\n\n
      \n\n\n\n
      Struggling with interview prep? Meet senior developers from Amazon, Microsoft, and Google now on Codementor. They\u2019ll help you tackle coding challenges, practice interviews, and sharpen your skills in live 1:1 sessions.

      Book a session with our interview prep tutors<\/a> today! Your first 15 minutes are free.<\/strong><\/p>\n\n\n\n
      Explore our other software development interview questions and answers to prep for your next remote job.<\/p>\n\n\n\n
      \n
      \n