Blog

In Ruby, type is determined by behavior (methods), not class.
If an object can perform required actions, it can be used.

def make_it_talk(obj)
  obj.talk
end

class Dog
  def talk; puts "Woof!"; end
end

class Human
  def talk; puts "Hello!"; end
end

make_it_talk(Dog.new)   # Woof!
make_it_talk(Human.new) # Hello!

Ruby does not support multiple inheritance. Instead, it uses Mixins (via include keyword).

module Walkable
  def walk
puts "Walking..."
  end
end

class Person
  include Walkable
end

p = Person.new
p.walk   #

self represents the current object.

Inside a class → self refers to the object calling the method.

For class methods → self refers to the class itself.

• Block: Anonymous piece of code passed to methods.

3.times { puts "Hello" }

• Proc: Saved block that can be reused.

say = Proc.new { puts "Hi" }
say.call

• Lambda: Like a Proc but stricter about arguments.

l = ->(x) { x*x }
puts l.call(5) # 25

• == → checks equality of values.
• === → used in case statements and can behave differently depending on the class.

5 == 5      # true
(1..10) === 5  # true (range check)

Symbols are immutable, reusable names represented with a colon :.
They are faster and consume less memory than strings.

:age   # symbol
"age"  # string

• puts → prints output with newline.
• print → prints without newline.
• p → prints with debugging info (shows object’s raw form).

Example:

puts "Hello"   # Hello (new line)
print "Hello"  # Hello (no new line)
p "Hello"  

Pure OOP → Everything is an object.

Dynamic Typing → No need to declare variable types.

Duck Typing → If it “quacks like a duck”, it can be treated as one.

Garbage Collection → Memory management is automatic.

Mixins (Modules) → Instead of multiple inheritance, Ruby uses modules.

Ruby is a high-level, interpreted, object-oriented scripting language designed for simplicity and productivity. It has elegant syntax that is natural to read and easy to write.

• Designed by Yukihiro “Matz” Matsumoto in 1995.
• Popular because of Ruby on Rails framework.

ontent
“w” → write mode (creates file if not exist).

File.read → reads entire file content.

Output in console:

Hello Ruby File!
And file test.txt is created with that text.