Ruby on Rails is a server-side web application framework written in Ruby that follows the Model-View-Controller (MVC) architectural pattern. MVC separates the application into three interconnected components:

• Model: Manages data and business logic, interacts with the database
• View: Handles presentation layer and user interface
• Controller: Processes requests, coordinates between Model and View

Rails emphasizes convention over configuration and DRY (Don't Repeat Yourself) principles, making development faster and more maintainable.

The main Rails directories include:

• app/ - Core application code (models, views, controllers, helpers, assets)
• config/ - Application configuration, routes, database settings
• db/ - Database schema, migrations, seeds
• lib/ - Extended modules and custom libraries
• public/ - Static files directly served by web server
• test/ or spec/ - Test files
• vendor/ - Third-party code
• Gemfile - Gem dependencies specification

Symbols are immutable and stored in memory only once, while strings create new objects each time. Rails prefers symbols because:

• Memory efficiency - symbols are stored once
• Performance - faster comparison operations
• Immutability - prevents accidental modification

# Symbol - same object_id
:name.object_id == :name.object_id  # true

# String - different objects
"name".object_id == "name".object_id  # false

Convention over Configuration means Rails makes assumptions about what you want to do and how you'll do it, rather than requiring you to specify every detail. Examples include:

• Model User maps to database table users
• Controller UsersController handles /users routes
• Primary keys are named id
• Foreign keys follow pattern table_id

This reduces the amount of code developers need to write and maintains consistency across projects.

ActiveRecord & Database

Migrations are Ruby classes that allow you to evolve your database schema over time in a consistent way. They provide:

• Version control for database schema
• Team collaboration on schema changes
• Database-agnostic schema modifications
• Rollback capabilities

class CreateUsers < ActiveRecord::Migration[7.0]
  def change
    create_table :users do |t|
      t.string :email
      t.timestamps
    end
  end
end

• find: Finds by primary key, raises ActiveRecord::RecordNotFound if not found
• find_by: Finds first record matching conditions, returns nil if not found
• where: Returns ActiveRecord::Relation with all matching records

User.find(1)                    # Raises error if not found
User.find_by(email: "a@b.com")  # Returns nil if not found
User.where(active: true)        # Returns Relation (chainable)

• render: Renders a view template without a new HTTP request, maintains instance variables
• redirect_to: Sends HTTP redirect response, triggers new request, loses instance variables

def create
  @user = User.new(user_params)
  if @user.save
    redirect_to @user  # New request to show action
  else
    render :new  # Renders new template with @user errors
  end
end

Rails console options:

• rails console or rails c: Standard console
• rails console --sandbox: Rolls back changes on exit
• rails console production: Production environment console
• rails dbconsole or rails db: Direct database console

# Sandbox mode - all changes rolled back
rails console --sandbox

# Production console
RAILS_ENV=production rails console

Rails provides three default environments:

• Development: Reloading, verbose errors, debugging tools
• Test: Isolated testing, fixtures, transaction rollback
• Production: Optimized performance, caching, error monitoring

# Check current environment
Rails.env.development?  # true/false
Rails.env  # "development"

# Environment-specific code
if Rails.env.production?
  # Production-only code
end

# Custom environments
RAILS_ENV=staging rails server

Each environment has its own configuration file in config/environments/ and database configuration.