Ruby on Rails - Introduction

Ruby on Rails - Introduction

What is Ruby?

Before diving into Rails, it’s essential to understand Ruby, the programming language Rails is built upon.

Ruby is often described as a blend of:

• Smalltalk’s conceptual elegance and pure object-orientation,
• Python’s ease of use and readability, and
• Perl’s pragmatic scripting capabilities.

Key characteristics of Ruby:

• A dynamic, open-source programming language with a focus on simplicity and productivity.
• Interpreted, similar to Perl, Python, and Tcl/TK.
• Truly object-oriented: In Ruby, everything is an object, including primitive types like numbers.

Why Ruby for Rails?

Ruby’s design philosophy and features make it an excellent fit for web development with Rails. Its popularity stems from:

• Readability and Conciseness: Ruby’s syntax is designed to be close to natural language, making it relatively easy to learn and read.
• Open Source: Available under a liberal license, fostering a large and active community.
• Rich Standard Library and Gems: A vast collection of libraries (called ‘gems’) for almost any task.
• Metaprogramming: Ruby allows programs to write or manipulate other programs (or themselves), which Rails heavily utilizes to reduce boilerplate code.
• Developer Happiness: A core tenet of the Ruby community, focusing on making development enjoyable and productive.

Considerations:

• Performance: Historically, Ruby’s execution speed was a concern compared to compiled languages. However, with advancements like YJIT (Yet Another JIT Compiler) in recent Ruby versions, performance has significantly improved for Rails applications.
• Concurrency and Parallelism: Ruby’s Global Interpreter Lock (GIL) in MRI (Matz’s Ruby Interpreter) means only one thread can execute Ruby code at a time per process. However, I/O-bound operations can release the GIL, allowing for concurrency. For CPU-bound tasks, multi-process architectures (like those used by Puma web server) or experimental features like Ractors offer parallelism.

Sample Ruby Code

Here’s a simple Ruby class:

# The Greeter Class
class Greeter
  def initialize(name)
    @name = name.capitalize
  end

  def salute
    puts "Hello, #{@name}! Welcome to the world of Ruby."
  end
end

# Create a new object
g = Greeter.new("rubyist")

# Call the salute method
g.salute

Output:

Hello, Rubyist! Welcome to the world of Ruby.

Embedded Ruby (ERB)

ERB (Embedded Ruby) is a templating system that allows you to embed Ruby code within text documents, most commonly HTML for web pages. Rails uses ERB extensively for its view templates.

ERB uses specific tags:

• <% ... %>: Executes the Ruby code within the tags. Nothing is printed to the output.
• <%= ... %>: Executes the Ruby code and prints the result of the expression to the output.
• <%# ... %>: A comment tag; the code within is ignored.

Example (template.html.erb):

<% page_title = "ERB Demonstration" %>
<% salutation = "Dear Developer," %>

<html>
<head>
  <title><%= page_title %></title>
</head>
<body>
  <p><%= salutation %></p>
  <p>This is an example of how ERB templates work in Rails views.</p>
</body>
</html>

When processed by Rails, this ERB template would generate HTML with the Ruby variable values interpolated.

What is Rails?

• Ruby on Rails (often just “Rails”) is a powerful web application framework written in Ruby.
• Created by David Heinemeier Hansson (DHH).
• It follows the Model-View-Controller (MVC) architectural pattern.
• Emphasizes Convention over Configuration (CoC) and Don’t Repeat Yourself (DRY) principles.
• Designed for rapid development of database-backed web applications.
• Open source and has a large, vibrant community.

Full-Stack Framework

Rails is a full-stack framework, meaning it provides tools and libraries for all layers of web application development:

• Database interaction (via Active Record ORM).
• Routing (mapping URLs to controller actions).
• Controller logic (handling requests and responses).
• View templating (generating HTML with ERB, Slim, Haml, etc.).
• Asset management (CSS, JavaScript, images via Sprockets or Webpacker/Shakapacker).
• Background jobs (Active Job).
• Real-time features (Action Cable).
• Email sending (Action Mailer).

Convention over Configuration

Rails makes assumptions about common naming conventions (e.g., a Book model maps to a books database table). By following these conventions, developers write significantly less configuration code compared to many other frameworks. The application’s structure and database schema often provide Rails with all the information it needs.

Rails Strengths

Rails offers features that boost developer productivity:

Metaprogramming

Rails leverages Ruby’s metaprogramming capabilities to dynamically define methods and behaviors, reducing boilerplate and making code more expressive. For example, Active Record automatically creates accessor methods for database columns.

Active Record

The Object-Relational Mapper (ORM) in Rails. It allows developers to interact with database tables as if they were Ruby objects, abstracting away much of the SQL. Active Record handles database connections, schema discovery, CRUD operations, associations, validations, and more.

Built-in Testing

Rails has a strong testing culture. It automatically generates test files (using Minitest by default) when you create models or controllers. Tools like fixtures or factories (e.g., FactoryBot) help set up test data. RSpec is a popular alternative testing framework.

Development Environments

Rails provides three default environments: development, test, and production. Each has slightly different configurations (e.g., caching behavior, error reporting, database used) tailored to its purpose, streamlining the development lifecycle.

Scaffolding

Rails can generate ‘scaffolding’ – a basic set of model, views, controller, and routes for a resource. This is useful for quickly getting a CRUD interface up and running, for prototyping, or for learning how Rails components fit together.