Ruby - Modules and Mixins

1. Introduction

In object-oriented languages, achieving code reusability and organization is pivotal. Ruby offers a powerful mechanism called modules to facilitate this. Moreover, when modules are used to add functionality to classes, they're often referred to as mixins. In this post, we'll dive into Ruby's modules and the concept of mixins.


A module in Ruby is a collection of methods, constants, and other module methods. It resembles a class, but there's a key difference: you can't create an instance of a module, nor can it inherit from another module or class. Mixins come into play when modules are included in classes to add additional functionalities, allowing classes to leverage multiple inheritances, which isn't natively supported in Ruby.

2. Program Steps

1. Define a module with some methods.

2. Define a class.

3. Include the module in the class, turning the module into a mixin.

4. Create an instance of the class and call the methods from the module.

3. Code Program

# Define a module named Drivable
module Drivable
  def start_engine
    "Engine started!"
  def stop_engine
    "Engine stopped!"
# Define a Car class
class Car
  # Include the Drivable module, making its methods available to Car instances
  include Drivable
# Create an instance of the Car class
my_car =
# Call the methods from the Drivable module on the Car instance
puts my_car.start_engine
puts my_car.stop_engine


Engine started!
Engine stopped!


1. We defined a module named Drivable that contains two methods: start_engine and stop_engine.

2. We then defined a Car class.

3. Inside the Car class, we included the Drivable module using the include keyword. By doing this, we effectively made Drivable a mixin for the Car class, which means the methods from Drivable are now available to instances of Car.

4. We created an instance my_car of the Car class.

5. Finally, we called the start_engine and stop_engine methods on the my_car instance. Even though these methods are not defined in the Car class directly, they are accessible because we mixed in the Drivable module.

This example showcases the power of modules and mixins in Ruby, enabling code reusability and simulating multiple inheritance without the complexities that often accompany it.