Ruby on Rails: Rapid Development and Convention Over Configuration
Convention Over Configuration
Rails philosophy: assume best practices, minimize configuration. Model User → database table users (plural, lowercase). Controller UsersController → routes to /users. View: user.show.erb renders automatically (no mapping needed). Generators: rails generate model User (creates model, migration, tests). Rails assumes structure: db/migrate/, app/models/, app/controllers/, app/views/. Benefits: new developers productive immediately (known structure). Trade-off: less flexibility (conventions are optional but encouraged). Model naming: class User < ApplicationRecord, attributes auto-mapped from database. Active Record: ORM (object-relational mapping). user = User.find(1) (fetch by ID), User.where(active: true) (query), user.save (persist). Associations: has_many, belongs_to, has_many through. Example: class Post < ApplicationRecord; belongs_to :user; end (FK user_id automatic). Validations: validates :email, presence: true, uniqueness: true (before save, error if invalid).
Rapid Development and Scaffolding
Scaffolding: rails generate scaffold Post title:string content:text (creates model, migration, controller, views). Output: full CRUD (Create, Read, Update, Delete) implementation ~200 lines of code generated automatically. Development speed: feature development 10-20x faster than Java/C# (less boilerplate). Built-in: database migrations (version control for schema). Migration: class CreateUsers < ActiveRecord::Migration; def change; create_table :users do |t|; t.string :name; t.string :email; t.timestamps; end; end. Rollback: rails db:rollback (undo last migration). Seeds: db/seeds.rb populates test data (rails db:seed). View templating: ERB (Embedded Ruby).
<%= user.name %>
(interpolation). Partials: <%= render 'user', user: @user %> (reusable components). Hotwire (Rails 7+): Turbo (SPA without JavaScript), Stimulus (lightweight JS framework). Turbo replace partial without page reload (<10ms update). Authentication: Devise gem (login/signup/password reset). Authorization: Pundit (role-based access control). Deployment: Capistrano (automated deployment script).Rails Application Server and Performance
Application server: Puma (default, multi-threaded). Configuration: workers 4, threads 5:5 (4 processes, 5 threads each, 20 concurrent requests). Performance: ~100-500 requests/second (simple endpoint, single server). Compared to: Node.js 500K/s, Go 200K/s, Python 50K/s. Database optimization: eager loading (avoid N+1). User.includes(:posts) loads posts in single query (vs separate query per user). Query monitoring: Active Record query logs. Caching: Rails.cache.fetch(:key, expires_in: 1.hour) { expensive_operation }. Fragment caching: cache partial output. Sidekiq: background job processing. SidekiqJob.perform_later (queue job, execute async). Example: send email after user signup (synchronously). Rails console: irb(main) prompt for debugging. rails c (access models, run code interactively). Database efficiency: connection pooling (reuse connections). Slow query logs: log queries >1 second (identify bottlenecks). Profiling: Rack Mini Profiler gem (profile requests, analyze bottlenecks).
API-Only Rails and Microservices
API mode: rails new myapp --api (no views, tailored for JSON). Serializers: ActiveModelSerializers. class UserSerializer < ActiveModel::Serializer; attributes :id, :name, :email; end. JSON output: { id: 1, name: "John", email: "john@example.com" }. Versioning: namespace :api do namespace :v1 do resources :users end end. Versioning strategy: /api/v1/users vs /api/v2/users (separate implementations). Authentication: JWT tokens. Authorization: pundit policies (resource-level). Rate limiting: Rack::Attack (prevent abuse). Example: limit 60 requests per minute per IP. CORS: rack-cors (allow cross-origin requests). Content negotiation: respond_to blocks. def show; respond_to { |format| format.json { render json: @user } }; end. Error handling: rescue_from (centralized error handlers). Serialization: JSONAPI standard (hypermedia links, included resources). Example: { data: { type: "users", id: "1", attributes: { name: "John" } }, included: [...] }.
Testing and Quality Assurance
Test framework: RSpec (BDD). Example: describe User do; it "is valid with valid attributes" do; user = User.new(name: "John"); expect(user).to be_valid; end; end. Factories: FactoryBot creates test objects. let(:user) { create(:user, name: "John") }. Fixtures: YAML files define test data. Database transactions: tests wrap in transaction (rollback after test). CI/CD: GitHub Actions (automated tests). Example: push → run tests → deploy if pass. Code coverage: SimpleCov (track coverage %). Coverage report shows untested lines. Linting: RuboCop (style enforcement). Performance testing: k6, Apache JMeter (load testing). Security scanning: Brakeman (detects Rails security issues). Dependency vulnerability: bundle audit (identify vulnerable gems). Testing best practices: unit tests (fast), integration tests (slow), E2E tests (via Capybara + Selenium).
Gems and Ecosystem
Gems: Ruby packages (equivalent to npm packages). Gemfile: lists dependencies. group :development do; gem 'pry' (debugging in development). group :test do; gem 'rspec-rails' (testing). Bundler: manages dependencies (bundle install). Rails gems: devise (auth), pundit (authorization), active_storage (file uploads), action_mailer (email), action_cable (WebSocket), paperclip (image processing). Popular gems: rails-api (legacy name for api mode), kaminari (pagination), elasticsearch-ruby (full-text search), sidekiq (background jobs). Concerns: gem quality (vet before use), security (known vulnerabilities). Ruby ecosystem: large, mature, thousands of gems. Version management: ruby-version file specifies Ruby version (rbenv, rvm manage versions).
Deployment and Maintenance
Capistrano: automated deployment. cap production deploy (upload code, restart server, zero-downtime). Releases: /releases/{{ timestamp }} structure (easy rollback). Database migrations: auto-run during deploy (or manual if careful). Monitoring: New Relic, DataDog track performance. Application errors: Sentry integration (exception tracking). Logs: /log/production.log (search for errors). Database backup: pg_dump (PostgreSQL backup). Docker: containerized Rails. Dockerfile: FROM ruby:3.2, COPY Gemfile, RUN bundle install, CMD ["rails", "server"]. Kubernetes: deploy Rails pods (load balancer routes traffic). Horizontal scaling: multiple Puma processes handle load. Cloud platforms: Heroku (PaaS for Rails), AWS (EC2/RDS), DigitalOcean (Droplets). Upgrade path: Rails 6 → 7 (gradually deprecate features). Dependencies: keep gems updated (security patches). Long-term maintenance: avoid dependency bloat (remove unused gems).