Forem: Hrishi Mittal

What is the difference between include and extend in Ruby?

Hrishi Mittal — Thu, 23 Jan 2025 16:25:42 +0000

This lesson is from Full Stack Rails Mastery.

In Ruby, include and extend are two Module methods that allow you to share functionality between classes, but they do so in subtly different ways.

This can lead to confusion, especially in a Rails context where both are commonly used.

In short: Use include for instance-level behaviour and extend for class-level functionality.This article looks at include and extend in detail, breaking down their differences and providing real-world examples from Rails applications to help you decide when to use each. The Basics of include and extend include: When you include a module, its methods become instance methods of the including class. This means every instance of the class gains access to the module’s methods.

Example:

module Greetable

  def greet

    "Hello!"

  end

end

class User

  include Greetable

end

user = User.new

puts user.greet  # Outputs "Hello!"

extend: When you extend a module, its methods become class methods of the extending class (or object). This means the methods are available on the class itself, not its instances.

Example:

module Greetable

  def greet

    "Hello!"

  end

end

class User

  extend Greetable

end

puts User.greet  # Outputs "Hello!"

Using extend on individual objectsYou can also use extend by calling it on an object. In our example above, if we didn't include the Greetable module in the User class, we can still run this on a User object like this:

module Greetable

  def greet

    "Hello!"

  end

end

user = User.new

user.extend(Greetable)

puts user.greet  # Outputs "Hello!"

When you call extend on an object (rather than a class), the methods from the module are added as singleton methods to that specific object. This allows you to modify the behaviour of individual objects dynamically, without affecting the class or other instances.

Here: 1. extend adds the greet method to this specific user object. 2. Other instances of User remain unaffected:

another_user = User.new

another_user.greet  # Raises a NoMethodError

Real-Life Use Cases in Rails Let’s explore common scenarios in Rails where include and extend are used effectively. 1. Using extend: Class-Level Behaviour Example: Adding user-friendly ids and slugs to a Model with the FriendlyId gem

class Article < ApplicationRecord

  extend FriendlyId

  friendly_id :title, use: [:slugged, :history, :finders]

end

Here, extend is used because FriendlyId provides methods like friendly_id that operate at the class level, configuring how slugs are generated and handled for the entire model. Other Examples: • Enumerize for defining enumerated attributes. • Utility methods for querying or filtering records (Searchable module).
2. Using include: Instance-Level Behaviour Example: Adding Background Job Functionality with Sidekiq::Job

class AddUserToMailingListJob

  include Sidekiq::Job

def perform(user_id)

    user = User.find(user_id)

    MailingList.add(user.email)

  end

end

Here, include is used because Sidekiq::Job provides methods that operate on instances of the job class. Sidekiq creates a new instance of AddUserToMailingListJob for each job execution. Other Examples: • Models: Adding reusable instance methods (e.g., Taggable for tags). • Controllers: Sharing logic via concerns (e.g., authentication filters).

Key Scenarios with Code Examples Scenario 1: Sharing Class-Level Utility Methods

module Searchable

  def search_by_name(name)

    where("name LIKE ?", "%#{name}%")

  end

end

class Product < ApplicationRecord

  extend Searchable

end

Product.search_by_name("Gadget")  # Class-level behaviour

Here, extend makes the search_by_name method available to the Product class for querying records. Scenario 2: Adding Reusable Instance Methods

module Taggable

  def tags_list

    tags.map(&:name).join(", ")

  end

end

class Post < ApplicationRecord

  include Taggable

end

post = Post.new

puts post.tags_list  # Instance-level behaviour

Here, include allows each instance of Post to access tags_list, which operates on instance-specific data. Scenario 3: Reusable Controller Logic

module Authenticated

  def authenticate_user

    redirect_to login_path unless current_user

  end

end

class AdminController < ApplicationController

  include Authenticated

  before_action :authenticate_user

end

Here, include adds authentication logic as reusable instance methods for controllers.

Another example is for pagination with the Pagy gem:

class ApplicationController < ActionController::Base

  include Pagy::Backend

end

In summary, use include for instance-level behaviour and extend for class-level functionality. By following the examples and guidelines above, you can write cleaner, more maintainable code in your Rails applications.

This lesson is from Full Stack Rails Mastery.

How to use Solid Queue for background jobs in Rails

Hrishi Mittal — Tue, 17 Dec 2024 10:29:36 +0000

This is a video lesson from the Full Stack Rails Mastery course.

Solid Queue is the new default way of running background jobs in Rails 8 apps. In this video lesson, I show you how to use Solid Queue with Active Job to send order confirmation emails in an ecommerce app.

If you enjoyed this lesson, you'll love the Full Stack Rails Mastery course!

Ruby Quiz

Hrishi Mittal — Tue, 03 Sep 2024 19:00:18 +0000

I just published a new Ruby Quiz as part of the Full Stack Rails Mastery course.

There are 10 questions randomly sampled from a bigger set, so every time you reload the page, you will get a different quiz.

Take the quiz, share your score and challenge your friends! :)

Rails 7.2 allow_browser version guard feature

Hrishi Mittal — Sun, 01 Sep 2024 16:01:25 +0000

This lesson is from Full Stack Rails Mastery.

If you're using Rails 7.2 or above, you might have run into an error like this when using a slightly older browser:

Your browser is not supported. Please upgrade your browser to continue.
In your Rails server logs, you will see:

Rendering public/406-unsupported-browser.html

Completed 406 Not Acceptable

The Rails server is returning a 406 Not Acceptable HTTP code response due to a new feature that allows you to specify which browsers can access your site.

The allowed versions are specified in ApplicationController with the allow_browser method.



class ApplicationController < ActionController::Base
  # Only allow modern browsers supporting webp images, web push, 
  # badges, import maps, CSS nesting, and CSS :has.

  allow_browser versions: :modern
end

The default value is set to :modern which refers to the following versions:



{ modern: 
  {
    safari: 17.2,
    chrome: 120,
    firefox: 121,
    opera: 106,
    ie: false
  }
}

These versions are from December 2023.

You can specify minimum versions for any browser and also whether they apply to all actions or some, using only and except. You can specify versions in ApplicationController and also in individual controllers for finer control.

For example, to allow all versions of Chrome and Opera, no versions of "internet explorer" (ie), Safari versions 16.4+ and Firefox 121+:



allow_browser versions: { safari: 16.4, firefox: 121, ie: false }

To block specific versions for specific controller actions, in addition to those specified in ApplicationController:



class ProductsController < ApplicationController
  allow_browser versions: { opera: 105, chrome: 119 }, only: :show
end

You can allow all versions by deleting or commenting out the allow_browser line.

Learn to build production apps with Ruby on Rails.

The 80/20 Rule of Rails performance

Hrishi Mittal — Thu, 22 Aug 2024 21:32:25 +0000

This lesson is from Full Stack Rails Mastery.

When it comes to speeding up Rails apps, sometimes people get too fancy and forget the most important fundamentals.

Like most things in life, the Pareto Principle (80/20 rule) applies to Rails performance too:

80% of your app's slowness is caused by 20% of slow code or infrastructure.

Now, don't get hung up on the exact numbers - the 80:20 ratio is a ballpark. The real numbers may be 90:10 or 75:25.

The point is: instead of trying to optimise every little detail, first focus on the big issues. The places where you will get the most bang for your buck.

And for most web apps, that's the DATABASE.

Before you do anything complicated like memory profiling or complex caching, optimise your database queries, which means two things:

1. Add indexes (or indices, if you please) to important columns - any columns you use for lookups (using the where clause) or for sorting records.

2. Avoid N+1 queries by eager loading associated records.
For example, on Learnetto when I load courses, I also load associated teacher records with includes.

courses = Course.includes(:teacher)

You can easily detect N+1 queries by looking at your Rails log and looking for multiple similar SQL queries.

Or you can use something like the bullet gem which automatically detects N+1 queries.

(A word of warning: Once I worked on a large client project and adding this gem started causing mysterious test failures, which had us tearing our hair out. After many hours of poring over stack traces, we realised the gem was the culprit, removed it and the problem went away.)

But here too, you must apply the 80/20 rule.
Not all N+1 queries are worth eliminating!

If you have a horrible N+1 query on a page of your website that no one ever visits, then it's not worth optimising (yet).

So, focus on the most popular pages and controller actions which your customers are actually touching.

For example, find the top 10 most visited pages on your site from your website analytics and optimise queries for those pages.

Or if you use an App Performance Monitoring (APM) system like New Relic or Scout, you can get better data.

In the New Relic dashboard, under the Transactions tab, you can see a list of transactions ranked by where users spend the most time (or by the slowest response times).

Below is an example from the courses#show transaction for Learnetto:

Another source of performance issue I've noticed is unnecessary gem dependencies.Including too many gems or heavy gems that are not really needed can bloat your application and slow down load times.A very common example of an unnecessary gem is a simple API wrapper for a third party service. I've found that 99% of the times, using a generic library for making HTTP calls is more than enough (Net::HTTP library or httparty gem).

The most recent example is when I wanted to use the OpenAI API in a fun project for Instagram profile analysis, I first reached for the ruby-openai gem. When I ran into some configuration issue before I could make my first API call, I decided to switch to httparty. It turned out to be perfectly adequate for my use case. And I was already using it in the project.So regularly audit your Gemfile, remove unused gems, and consider lighter alternatives or custom solutions for heavy gems that are only partially used.

What other low hanging fruit do you first check for when you want to speed up your Rails app?

Ruby on Rails API Quiz

Hrishi Mittal — Sun, 18 Aug 2024 10:36:25 +0000

Here's a challenging API quiz for Rails developers.

I posted another quiz here a few days ago.

This one is updated and more fun! It gives you 10 random questions from a bigger set.

And at the end you can also see which ones you got wrong and their correct answers.

See how many questions you can answer correctly and challenge your friends.

Post your score in the comments!

If you enjoyed this quiz, check out my Rails course for more quizzes.

How to setup Rails Guides for offline use

Hrishi Mittal — Sat, 03 Aug 2024 10:35:12 +0000

This lesson is from Full Stack Rails Mastery.

The official Ruby on Rails Guides are an essential part of a working Rails developer's reference library. While it's easy enough to look them up online, it's also a great idea to keep a copy on your computer for easy offline access.

It comes in handy if you find yourself somewhere with weak or no internet connectivity and need to look something up quickly.

The guides are inside the Rails repository - https://github.com/rails/rails/tree/main/guides.

Start by downloading the repo to your machine. You can download the zipped file or run one of the following commands on your terminal.

Using the HTTPS url:

git clone https://github.com/rails/rails.git

Or SSH:

git@github.com:rails/rails.git

Or the Github CLI:

gh repo clone rails/rails

Then cd into the directory and install the gem dependencies:

cd rails-main
bundle install

Then cd into the guides directory:

cd guides

And run:

rake guides:generate

That will generate the HTML version of the guides and put them in a new output directory inside the guides directory. You can open output/index.html to see the guides homepage, which links to all the guides.

You can also specify the HTML format like this:

rake guides:generate:html

Note that this is the Edge version of the guides, since we are generating them from the main branch.

If you want to generate the guides for a specific Rails version, you can pass RAILS_VERSION as an argument:

rake guides:generate:epub RAILS_VERSION=7.1.0

If you prefer an ebook format to use on your Kindle, Apple Books or other ereader device, you can generate the guides in epub by running:

rake guides:generate:epub

Note that the old kindle option for generating .mobi files has been deprecated.

Some other arguments you can pass are ONLY (if you only want specify specific guides):

rake guides:generate ONLY=assoc,migrations

What's cool is that since you have the code for generating the guides, you can customise them any way you like!

Ruby on Rails Quiz

Hrishi Mittal — Wed, 31 Jul 2024 08:55:38 +0000

I made a quiz for Rails developers - https://learnetto.com/rails-quiz

How many questions can you answer correctly?

Post your score in the comments!

How to build an image gallery in Rails with Stimulus

Hrishi Mittal — Mon, 29 Jul 2024 17:53:53 +0000

This is a video lesson from the Full Stack Rails Mastery course.

In this lesson, we’ll create an interactive image gallery for the product page using Stimulus.

Here we have all the thumbnails of the product’s images and the first one is displayed as a large image.

We want to be able to click on any thumbnail to see the large version of it above.

Stimulus is a part of Hotwire. It’s "a modest JavaScript framework for the HTML you already have".

Stimulus gives you a lightweight way to add interactivity to webpages.
You start by adding 3 data attributes to your HTML:

controller
target
action

Stimulus automatically connects DOM elements to JavaScript objects called controllers.

The controller is where you define the logic of the interaction.

In the example on the Stimulus homepage, there's a form with an input text field where you can enter a name. When you click greet, it displays the text “Hello” with the entered name.

<div data-controller="hello">
  <input data-hello-target="name" type="text">

  <button data-action="click->hello#greet">
    Greet
  </button>

  <span data-hello-target="output">
  </span>
</div>

So the first data attribute is controller with the value "hello".

You set that on the outer div which contains the rest of the UI elements.

There are two targets - one for input called name and another for the output.

And there's an action attribute set on the button with the value "click->hello#greet".

This means when the button is clicked, call the greet method in the hello controller.

Now, let’s look at the controller code.

// hello_controller.js
import { Controller } from "stimulus"

export default class extends Controller {
  static targets = [ "name", "output" ]

  greet() {
    this.outputTarget.textContent =
      `Hello, ${this.nameTarget.value}!`
  }
}

We start by importing the built-in Controller class from Stimulus. We will extend this to define our own hello controller.
import { Controller } from "stimulus"

export default class extends Controller {

Note the naming convention here. The file is called hello_controller.js. That’s the controller name followed by "_controller.js". The name hello is what's used as the identifier value for the data-controller attribute on the container div.

Next we define a list of targets as static properties on the class.

  static targets = [ "name", "output" ]

Targets map HTML elements to controller properties.

We have two targets here - the input name and the output.

Stimulus will automatically create corresponding properties for each of them - this.nameTarget and this.outputTarget respectively.

Again, note the naming convention here. this dot the name of the target followed by the word Target with a capital T.

Finally, we have the greet method definition:

  greet() {
    this.outputTarget.textContent =
      `Hello, ${this.nameTarget.value}!`
  }

The backticks mean it’s a template literal, and the dollar curly brackets ${ } are used to embed an expression within the string. This is similar to string interpolation in Ruby with hash curly brackets #{ }.

Now that we have the basic idea of how Stimulus works, let’s put it to use by building our very own first Stimulus controller.

Instead of coding it from scratch, we can use a Rails generator:

bin/rails generate stimulus gallery

And that will create gallery_controller.js in app/javascript/controllers.

import { Controller } from "@hotwired/stimulus"

// Connects to data-controller="gallery"
export default class extends Controller {
  connect() {
  }
}

First we import the Controller class from stimulus and then extend it.

Stimulus has automatically added a method called connect.

This is a special method - a lifecycle callback. There are a few of these special methods. connect runs anytime the controller is connected to the DOM.

To see it in action, let’s add a console log statement that says image gallery controller connected.

connect() {
  console.log('image gallery controller connected')
}

Then we need to define a data-controller attribute so Stimulus knows which DOM element to connect this controller to.

Let’s go to the product partial (app/views/products/_product.html.erb) and add a data controller attribute to the outermost div. And set its value to gallery.

  <div class="min-h-screen py-12 sm:pt-20" data-controller="gallery">

Now refresh the page in the browser and we see our log message in the console.

Next, let’s set the data-action attribute on the thumbnails. Because that’s what we want to click. We set the action to a method called “display”.

<%= image_tag image, class: "thumbnail", data: {action: "click->gallery#display"} %>

Ok, now let’s define this display method in the controller. First, let’s simply console log a message “display clicked image”. So we know our action attribute is working correctly.

display() {
  console.log('display clicked image')
}

Let’s test it in the browser. Refresh and click a thumbnail. And there we have our second console log message.

Ok now, we need one more data attribute - a target.

That would be the big image at the top of the gallery. So inside that image tag, let's add data “gallery-target” and we’ll call it “display”.

<%= image_tag product.images.first, id: "displayed-image", 
              data: { "gallery-target": "display" } %>

If we refresh and look at the elements in the console, we can see the data attributes we’ve set.

Ok, now let’s proceed with defining the rest of the controller.

First, let’s define our static targets. We only need one here called “display”:

static targets = ["display"]

And finally, let’s define the logic of the display method. Let’s remove the console log statement.

We want to set the value of the src attribute of the display target image.

So we can write:

display() {
  this.displayTarget.src = event.currentTarget.src
}

Remember the naming convention here - target name “display” followed by the word Target with a capital T.

We can get the src of the thumbnail image via “event” i.e. the click event which we used in the data-action attribute.

currentTarget is the DOM target on which the data-action attribute is defined. In this case, it’ll be whichever thumbnail image is clicked.

Ok, now let’s try that in the browser. Refresh and click a different thumbnail And there you go - the big displayed image changes to that one. Try clicking another one and it works.

So there you have it - we have created our first Stimulus controller. We were able to create an image gallery with very little code!

If you enjoyed this lesson, you'll love the Full Stack Rails Mastery course!

How to deploy a Rails 7 app to Fly.io

Hrishi Mittal — Thu, 25 Jul 2024 09:05:36 +0000

This is a video lesson from the Full Stack Rails Mastery course.

In this 5-minute lesson, you'll learn how to deploy a simple Rails 7 app to Fly.io, a popular web hosting service.

Some common errors you may run into when deploying to Fly.io:

500 error on deploy

If you get a 500 error on deploy, it may be because the database did not get set up or migrated. You need these lines in your fly.toml file:

[deploy]
  release_command = './bin/rails db:prepare'

Sometimes Fly removes that command, which causes the 500 error.

Missing assets

If you find that your CSS is not loading, even though the link tags look fine, it could be because these lines are missing or incorrect in fly.toml:

[[statics]]
  guest_path = '/rails/public'
  url_prefix = '/'

It's something Fly adds to serve assets directly from its cache (which is not quite a CDN), bypassing your web server. Sometimes the guest path is set to an incorrect value.

How to write a good resume

Hrishi Mittal — Fri, 14 Jan 2022 15:38:42 +0000

The purpose of a resume is to clearly convey your top skills and establish credibility through past work experience, projects and educational qualifications.

Start with the audience in mind - who reads your resume?

Recruiter
Hiring manager
CTO, Senior Developer, Tech lead, Engineering Manager

Here are some tips for how to make your resume stand out:

Mirror the language of the job/role description.

Many companies use applicant tracking systems (ATS) - software for automatically scanning and filtering resumes before any human reads them. You need to make sure your resume gets through that by including all the most important keywords relevant to the contract.

You can also run your resume through an online ATS scanner like Jobscan, which gives you a match score by comparing your resume and job descriptions.

But don't take it too literally. Their algorithm is too simplistic. If you added all the keywords they recommend, your resume would become a list of buzzwords.

Instead, just look out for any obvious important keywords you're missing and add them.

Keep your resume short - no more than 1–2 pages long.

You only need to provide enough information to get an interview. Avoid including irrelevant projects, certifications or hobbies.

Use results-oriented active verbs.

For example, try to use words like "shipped", "delivered", and "led" instead of "took part in", "wrote code" or "was part of team".

Where possible, quantify the impact of your work.

If you can attach any monetary ($) value to your work, make sure to mention it. But keep it real - don't inflate the impact and never lie.

Make sure to mention any performance improvements you delivered. For example, "Improved website load times by 25% during peak shopping season".

Or at least mention a qualitative benefit to the business. For example, "simplified onboarding process for new vendors on platform by automating upload of key documents".

If you led a team, mention how many team members there were.

If you built some tool used by your employer, mention how many people in the company or how many customers used it.

Mention the key technologies used.

For each line item of work experience, make sure to mention the key tech stacks used. This ties back to the point above about ATS.

But don't just list lots of programming languages, frameworks and tools without the context in which you used them.

Use a good simple template.

You can use a simple one from Google docs or a nicer one from Canva - https://www.canva.com/resumes/templates/

Avoid using overly fancy non-standard layouts or colour schemes.

Tailor your resume for each job or contract.

It's a bit more of an effort, but you can really stand out if you emphasise parts of your experience that are particularly relevant to a company.

Make it easy to scan quickly.

Bold words throughout your resume to highlight and draw attention to important keywords. No one will read your entire resume, so make it easy to scan.

Link to your important online profiles

At the top of the resume, include links to your personal website, Github profile, portfolio, LinkedIn profile and any other relevant professional profiles.

If your Github profile does not have any relevant projects, then it's better not to link to it. Showing an empty or inactive profile is worse than not showing one.

Highlight your strengths, not weaknesses.

Highlight your non-coding skills.

Non-technical skills can be very important, especially as a contractor. So make sure to highlight:

relevant personal projects
any talks you've given
articles or videos you've published
community or leadership initiatives
experience in mentoring others
experience in hiring - screening or interviewing candidates
open source contributions, including documentation and community management
relevant courses and certifications you have completed

These are doubly important if you don't have enough relevant work experience.

Do you have any other tips or questions? Share them in the comments below.

This lesson is from my 6-Figure Contractor Group Coaching Program - a 4-week cohort-based course in which I help developers like you kickstart their careers as contractors. Learn more here and sign up for the next cohort.

Learn to make and sell

Hrishi Mittal — Fri, 07 Jan 2022 18:06:24 +0000

Making and selling are the two most valuable skills you can master this year.

And I mean making and selling in the broadest terms.

As a developer, making comes naturally to you. But in addition to making software, I also mean making other things - music, stories, furniture, paintings.

As a developer, you might not be keen on selling. But I'm not talking about the cliched image of a used car salesman.

By selling, I mean presenting yourself well and convincing others to use your services or products.

For example, if you're looking for a new job this year. Or starting out as a freelancer. You will need to learn to sell yourself.

So, the new theme for my startup Learnetto this year is to help you learn to make and sell.

Look out for lots of great new content on both those topics.

Make sure you sign up to our newsletter to get the latest content first.

Happy new year!

PS Btw, are you interested in teaching? I'm looking for people to help me create new educational content (tutorials, videos, workshops) on Learnetto. Email me at hrishi@learnetto.com and tell me what you can teach. If you have any examples, then please include some links to your work.