DEV Community: Chaitali Khangar

The Factory Method Pattern: The Secret Behind Scalable Code

Chaitali Khangar — Wed, 12 Nov 2025 15:52:39 +0000

A few years ago, I worked on a growing application that started small but expanded faster than we expected.

Each new feature introduced a new way to create objects - notifications, reports, services - and every time, we added another if-else block.

At first, it was fine.

Then one day, a minor change broke three modules because a single creation method was edited in multiple files.

That's when I realized the problem wasn't in the logic - it was in the design.

We weren't managing object creation; we were repeating it.
That's when I discovered design patterns.

Why Design Patterns?

As applications evolve, developers often face the same structural problems repeatedly.

How do you create objects without duplicating logic?
How do you extend functionality without breaking existing code?

Instead of solving these problems from scratch every time, developers started identifying and documenting reusable approaches.

That led to the Gang of Four (GoF) book - Design Patterns: Elements of Reusable Object-Oriented Software (1994).

A design pattern isn't a library or a framework.
It's a reusable way to think about recurring design challenges.

The Real Problem

Imagine you're building a notification service.
You start with a simple design:

if type == :email
  Notification::Email.new
elsif type == :sms
  Notification::Sms.new
else
  Notification::Push.new
end

It works.

But as the system grows, more notification types appear - Slack, WhatsApp, internal alerts.

Each new type means another line, another edit, another potential mistake.

Your code is now doing two things:
Running business logic.
Deciding which class to create.

This is exactly the kind of problem the Factory Method Pattern solves.

What Is the Factory Method Pattern?
The Factory Method Pattern is a creational design pattern that provides an interface for creating objects without specifying their concrete classes.

In other words, you tell the system what you need, and it decides how to build it.

How It Works
Let's refactor the earlier example.

class NotificationFactory
  def self.build(type)
    klass_name = "Notifications::#{type.to_s.camelize}"

    if Object.const_defined?(klass_name)
      klass_name.constantize.new
    else
      raise "Unknown notification type: #{type}"
    end
  end
end
module Notification
  class Email
    def send_message
      puts "Sending email..."
    end
  end

  class Sms
    def send_message
      puts "Sending SMS..."
    end
  end

  class Push
    def send_message
      puts "Sending push notification..."
    end
  end
end

# When you call
notification = NotificationFactory.build(:email)
notification.send_message
# Output: Sending email...

notification = NotificationFactory.build(:whatsapp)
notification.send_message
# Output: Unknown notification type: whatsapp

Now you have implemented a Factory Method pattern.

In the future, if a new type Slack is added,
You just define the class inside Notification- no change in the factory, no code broken.

Visual Flow
Here's how this example works conceptually:

This is the essence of the Factory Method Pattern -
The client doesn't care which class was created.
It just asks the factory, and the right object is returned.

How Major Frameworks Use It

The Factory Method Pattern is everywhere - even if you don't notice it.
Rails:
When you call validates :email, presence: true, Rails dynamically decides whether to use PresenceValidator, LengthValidator, or FormatValidator.

React:
React.createElement(type) determines which component to render at runtime.

When (and When Not) to Use the Factory Method Pattern

Before applying it, here's a quick decision framework to help you decide whether the Factory Method Pattern is the right choice.

Use the Factory Method Pattern when:

You have multiple related object types.
You expect to add more types in the future.
You want to centralize and simplify object creation logic.

Avoid it when:

The number of types is fixed and small.
Simplicity matters more than scalability.

Now you've seen how replacing scattered if-else statements with intentional creation logic brings clarity and structure.

You're not just improving readability - you're building for the future.

Till next time - build systems that grow, but never crumble.

ruby #rails #designpatterns #factorymethod

Dynamic Data Management with jsonb in Rails

Chaitali Khangar — Tue, 16 Apr 2024 11:42:46 +0000

Ever feel stuck trying to manage data fields that constantly evolve in your application?

You're certainly not alone.

Many developers face this challenge when building applications that require flexible data structures.

But there's a solution!

PostgreSQL's jsonb data type is here to help.

Let's explore how jsonb helps you to handle dynamic data with ease.

What is jsonb?

It's a data type designed specifically to store flexible and dynamic data in the structured format of JSON (JavaScript Object Notation).
Think of it as a way to store key-value pairs within your database table, allowing you to define data as your application's needs grow.

Example:

"product_properties": {
  "color": "blue",
  "price": 19.99
}

In this example, product_properties is a jsonb column that stores product details like color and price. You can effortlessly add new properties (like size or material) without modifying your database schema.

Why jsonb over json?

Jsonb stores data in a binary format, which results in more efficient storage and faster retrieval.
Jsonb support indexing
Jsonb provides a larger set of functions and operators for querying and manipulating JSON data.

When to use jsonb?

Flexible Schemas: Ditch rigid table structures! jsonb allows your data to adapt as your application's needs change.
Dynamic Attributes: Need to store user preferences or custom product information? jsonb handles it beautifully.

How to use jsonb?

Here's a quick three-step guide to using jsonb in your Rails project:

Step1: Create a Migration Add a jsonb column to your table using a migration. Here's an example using Rails:

add_column :products, :properties, :jsonb, null: false, default: '{}'

Step2: Setting Values Treat your jsonb column just like any other object. Assign values using key-value pairs:

product = Product.first
product.properties = { 'color': 'blue', 'price': 19.99 }
product.save

Step3: Accessing Values Retrieve data based on keys or values

SQL way

select * from products where (products.properties->>'color')::varchar = 'blue';

Rails Way

Product.where("(products.properties->>'color')::varchar = 'blue'")

Remember: jsonb values can be null.

Use the following to check for existing keys:

SQL way

select * from products where (products.properties->>'color') is not NULL;

Rails Way

Product.where("products.properties->>'color' is not NULL")

Embrace the Power of jsonb!

With jsonb you can say goodbye to those frustrating moments when dealing with dynamic data in your PostgreSQL database.

Now you can store and retrieve information in a structured and flexible way. This gives your application the agility to adapt and grow as your needs evolve.

Till we meet, next time Happy Coding!!

The Art of Monkey Patching in Ruby

Chaitali Khangar — Tue, 26 Mar 2024 05:54:25 +0000

Ruby, celebrated for its dynamic nature and Metaprogramming capabilities, offers a wealth of powerful features that are often underutilized or misunderstood.

In this blog, we'll shed light on a fascinating topic within Ruby known as Monkey Patching.

We are going to cover:

What is Monkey Patching?
How can we apply Monkey Patching?
What happens when Monkey Patching goes wrong?
Is there an alternative approach?

Let's wear our Ruby hats and start diving into the concept of Monkey Patching.

What is Monkey Patching?

Ruby is a dynamic programming language and its interpreted language which gives you the ability to write or modify the code at Runtime.

Imagine you could add new abilities to existing things in Ruby.

That's what open classes or Monkey Patching.

Monkey Patch, lets you change or add things to existing stuff, like teaching a phone new tricks.

Why do we use it?

When you want to make something better without changing the original code.

How can we apply Monkey Patching?

Now we know what it is, let's dive into coding.

require 'date'

# TO check if date class has leap_year? method or not
p Date.methods.include?(:leap_year?)
# Output: false

class Date
  def leap_year?
    (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)
  end
end

date = Date.new(2023, 10, 29)
p date.leap_year?
# Output: false

date = Date.new(2024, 2, 29)
p date.leap_year?
# Output: true

In this example, we open the Date class, that's why it is called an Open Class.

You are adding a new leap_year? method here that is called Monkey Patching.

What happens when Monkey Patching goes wrong?

While open classes are powerful, using them too much or in the wrong way can make things confusing or unpredictable.

Don't change the main things without thinking, as it might make others confused or stop things from working together.

Now let's understand this by example.

# Check if a method exists
String.methods.include?(:to_alphanumeric)

# Redefine class
class String
  def to_alphanumeric
    gsub(/[^\w\s]/, '')
  end
end

p "Hello, @World!".to_alphanumeric
# Output: Hello World

p "Ruby is #1 for coding!".to_alphanumeric
# Output: Ruby is 1 for coding

Now whenever you are calling the to_alphanumeric method on the String class you will get the same result.

This changes the global definition of the to_alphanumeric method of the String class.

Now consider third-party applications/gems if they have the same method to_alphanumeric for the String class, then it will behave differently, it will use your code instead of executing third-party applications or gem code.

We don't want this, to impact globally.

How can we solve this?

Is there an alternative approach?

Ruby 2.0 came up with a great feature to solve this issue. It's called Refinement.

What exactly is 'Refinement' all about?

It allows you to modify the behavior of a class or module temporarily while ensuring it doesn't impact the global definition.

Provides a way to extend a class locally.

Refinements can modify both classes and modules.

How can we implement the Refinement feature?

module ToJSON
  refine Hash do
    def to_json
      '{' + map { |k, v| k.to_s.dump + ':' + v.to_s.dump }.join(',') + '}'
    end
   end
end

hash = {1=>2}
p hash.to_json

# Output: undefined method `to_json' for {1=>2}:Hash (NoMethodError)

Oops, an error is thrown.

What's the reason behind the error? The reason is it does not modify the global definition for the Hash class.

But hold on, we need these changes for the 'Hash' class, to fix this we must utilize the 'using' keyword.

module ToJSON
  refine Hash do
    def to_json
      '{' + map { |k, v| k.to_s.dump + ':' + v.to_s.dump }.join(',') + '}'
    end
   end
end

module ConvertToJson
  using ToJSON
  def self.convert(hash)
    p hash.to_json
  end
end

hash = {1=>2}
ConvertToJson.convert(hash)
# Output: "{\"1\":\"2\"}"

Yay, we've accomplished this without affecting the global definition of Hash.

Let's discuss the Scope of Refinement:

It's in the refine block itself.
Code starts from the place where you call using until the end of the module.

Now you understand how Monkey Patching works, why Refinement is introduced, and how you can use it.

Refactor your Monkey Patches or Refinements, and review your code to ensure they still serve your project's goals.

If you want to use it, go ahead as now you know how you can use Refinement to prevent global scope.

Till we meet next time, Happy Coding!!

Colorful Text in Rails with ANSI Escape Codes

Chaitali Khangar — Mon, 25 Mar 2024 08:10:07 +0000

Ever wonder about how Rails produces those vibrant, colorful displays for RSpec and Logger?

Take a look at this piece of Ruby code:

puts "\e[32mHi"

🧐 'Hi' appears in dazzling green.

Here's the magic behind it: ANSI escape codes.

These codes were cleverly designed in programming languages to provide developers with a standardized way to control the format and appearance of text in terminal/console output.

When do we use this?

1️⃣ Enhanced Readability: ANSI escape codes make text more readable by allowing developers to change colors, styles, and backgrounds, ensuring that important information stands out.

2️⃣ Visual Feedback: These mystical codes offer visual cues to users, from progress bars to color-coded status updates.

3️⃣ Debugging and Logging: They help format debugging and logging messages, enabling developers to quickly identify the severity of issues based on text appearance.

4️⃣ Interactive Interfaces: ANSI escape codes make command-line applications more interesting by allowing them to create interactive user interfaces.

Where does Rails work its magic with these codes?

RSpec
Logger's Colorful Logs
Colorful Console Output

Here is the bonus:

If you want to check where ANSI code exists in Rails feel free to reach out:

https://github.com/rails/rails/blob/6c9967f85ada90f8ca58e794a850e887ceb45132/activesupport/lib/active_support/log_subscriber.rb#L76

https://github.com/rspec/rspec-core/blob/1c662c35f91f33946fdfbed431878f4798f06f70/lib/rspec/core/formatters/console_codes.rb#L47

Till we meet next time. Happy Coding!!

The Curious Case of puts: A Ruby Detective Story

Chaitali Khangar — Thu, 21 Mar 2024 14:10:19 +0000

Ever wonder where the puts method comes from in Ruby?

Let's check out that together.

puts.class # => NilClass

It returns NilClass. But why?

It's because calling puts without arguments returns nil, signifying the absence of a specific value.

NilClass represents this very concept – the lack of a defined value.

Now, to unravel the true origin of puts, we will execute this code:

puts_method = method(:puts)
puts puts_method.owner

This code reveals that puts originates from the Kernel.

Let's check out whether Kernel is a class or a Module.

Kernel.is_a? Class #=> false
Kernel.is_a? Module #=> true

This clarifies that Kernel is a module.

But, how do puts magically work without a receiver?

In Ruby, the "Object" class includes the Kernel module.

This makes Kernel an essential part of every object's ancestry.

As Ruby code runs within an object, you can call Kernel's instance methods from anywhere in your code.

So, next time you use 'puts' in your Ruby code, remember its origins in the Kernel module and how it seamlessly integrates into every object's ancestry, making it accessible from anywhere in your code.

Till we meet, Happy Coding!!