Overview of Ruby

Ruby is an interpreted, high-level, general-purpose programming language designed by Yukihiro "Matz" Matsumoto in the mid-1990s. Its primary design philosophy centers on "developer happiness" and "the principle of least surprise." It is fully object-oriented, meaning every piece of data is an object, including primitive types and methods.

Environment Setup

On Unix-like systems, Ruby is often pre-installed or can be managed via package managers. To install the full Ruby suite on a Debian-based system:

sudo apt update
sudo apt install ruby-full

Developers frequently use managers like rbenv or rvm to handle multiple versions. To test code snippets instantly, Ruby provides irb (Interactive Ruby), a REPL environment accessible from the terminal.

Core Syntax and Control Flow

Ruby syntax is clean and lacks excessive punctuation. Variable assignment does not require explicit keywords for scope declaration like some other scripting languages.

# Variable assignment
app_name = "TechAnalytics"
threshold = 100

# Conditional logic
if threshold > 150
  puts "Critical Level"
elsif threshold > 80
  puts "Warning Level"
else
  puts "Normal"
end

Object-Oriented Programming (OOP)

Ruby encapsulates data and behavior within classes. It supports inheritance, access modifiers, and attribute accessors.

class Vehicle
  attr_accessor :brand, :speed

  def initialize(brand, speed)
    @brand = brand
    @speed = speed
  end

  def accelerate
    @speed += 10
    puts "Current speed: #{@speed}"
  end
end

car = Vehicle.new("Tesla", 0)
car.accelerate

Modules and Mixins

Modules serve two purposes: namespacing and mixins. Since Ruby does not support multiple inheritance, modules allow developers to share behavior across multiple classes through the include keyword.

module Logger
  def log_info(message)
    puts "[INFO] #{Time.now}: #{message}"
  end
end

class DatabaseConnector
  include Logger
end

db = DatabaseConnector.new
db.log_info("Connection established")

Blocks, Procs, and Lambdas

Closures are a powerful feature in Ruby. Blocks are chunks of code that can be passed to methods, often used for iteration.

numbers = [10, 20, 30]

# Using a block with an iterator
numbers.map! { |n| n * 5 }
# Result: [50, 100, 150]

# Explicit Enumerator usage
enum = numbers.to_enum
puts enum.next # => 50

Regular Expressions

Ruby has first-class support for Regular Expressions (RegEx), making text processing highly efficient.

email_pattern = /\A[\w+\-.]+@[a-z\d\-.]+\.[a-z]+\z/i
email = "user@example.com"

if email =~ email_pattern
  puts "Valid email format"
end

Exception Handling

Ruby uses begin, rescue, ensure, and end blocks to handle runtime errors gracefully.

begin
  result = 100 / 0
rescue ZeroDivisionError => e
  puts "Error encountered: #{e.message}"
ensure
  puts "Cleanup operations performed"
end

Metaprogramming Capabilities

One of Ruby's most distinct features is metaprogramming—the ability to write code that writes code at runtime. This is achieved through methods like define_method and class_eval.

class DynamicGenerator
end

DynamicGenerator.class_eval do
  define_method(:runtime_method) do
    "This method was created dynamically"
  end
end

instance = DynamicGenerator.new
puts instance.runtime_method

Web Development and Frameworks

The Ruby ecosystem is famous for Ruby on Rails (RoR), a framework that popularized the Model-View-Controller (MVC) architecture and "Convention over Configuration."

# Simple Rails Model
class Article < ApplicationRecord
  validates :title, presence: true
end

# Simple Rails Controller
class ArticlesController < ApplicationController
  def show
    @article = Article.find(params[:id])
  end
end

Testing with RSpec

Behavior-Driven Development (BDD) is a staple in the Ruby community. RSpec is the most common tool for writing human-readable tests.

RSpec.describe "Math operations" do
  it "calculates the sum correctly" do
    expect(5 + 5).to eq(10)
  end
end

Concurrency and Threading

While CRuby (the standard implementation) uses a Global Interpreter Lock (GIL), it still supports multi-threading for I/O-bound tasks.

worker = Thread.new do
  5.times { sleep(1); puts "Background task running..." }
end

worker.join

System Operations and Networking

Ruby provides robust libraries for file I/O and network communication.

# File Writing
File.write("output.log", "System initialization...")

# Basic TCP Client
require 'socket'
begin
  server = TCPSocket.open("localhost", 8080)
  server.puts "GET / HTTP/1.1"
  server.close
rescue Errno::ECONNREFUSED
  puts "Server unreachable"
end

Data Persistnece with ActiveRecord

ActiveRecord is the Object-Relational Mapping (ORM) layer used to interact with databases without writing manual SQL.

# Fetching data using ActiveRecord DSL
user = User.where(active: true).first
user.update(last_login: Time.now)

Memory Management

Ruby handles memory automatically through a Mark-and-Sweep garbage collection (GC) mechanism. Objects no longer referenced by the application are eventually reclaimed by the GC, though developers can manually trigger it using GC.start if necessary.

The RubyGems Ecosystem

RubyGems is the standard format for distributing Ruby programs and libraries. These "gems" can be installed via the command line to extend application funcitonality instantly.

gem install nokogiri
gem install devise