Comprehensive Rails Developer Guide.md

Comprehensive Rails Developer Guide

This comprehensive guide covers the progression from Junior to Principal Rails Developer, providing detailed explanations and code examples for each skill level. It serves as a roadmap for developers looking to advance their Rails expertise and tackle increasingly complex challenges in web application development.

Table of Contents

1. Junior Rails Developer

   1. MVC Architecture
   2. Ruby Basics
   3. ActiveRecord Basics
   4. RESTful Routes
   5. Rails Generators
   6. Migrations
   7. CRUD Operations
   8. Basic HTML and CSS
   9. Git Basics
   10. Rails Console

2. Mid-level Rails Developer

   1. ActiveRecord Associations and Validations
   2. Authentication
   3. Authorization
   4. Asset Pipeline
   5. Caching Strategies
   6. Background Jobs
   7. Testing with RSpec
   8. JavaScript and jQuery Integration
   9. API Development and Consumption
   10. Database Indexing and Query Optimization

3. Senior Rails Developer

   1. Advanced ActiveRecord Queries
   2. Service Objects and Design Patterns
   3. Performance Optimization Techniques
   4. Security Best Practices
   5. Scaling Rails Applications
   6. Advanced Testing
   7. Continuous Integration/Continuous Deployment (CI/CD)
   8. Refactoring and Code Organization
   9. WebSockets and Action Cable
   10. Internationalization (i18n) and Localization

4. Principal Rails Developer

   1. System Architecture Design
   2. Microservices Architecture
   3. Event-driven Architecture
   4. Domain-Driven Design (DDD)
   5. Database Sharding and Replication
   6. Distributed Systems and Eventual Consistency
   7. Cloud Infrastructure
   8. Containerization and Orchestration
   9. Machine Learning Integration in Rails
   10. Technical Leadership and Mentoring

Junior Rails Developer

MVC Architecture

Understanding of Model-View-Controller pattern, the role of each component (Models for data and business logic, Views for user interface, Controllers for request handling), and the flow of data and control in a Rails application.

Example:

# app/models/user.rb
class User < ApplicationRecord
  validates :email, presence: true, uniqueness: true
end

# app/controllers/users_controller.rb
class UsersController < ApplicationController
  def index
    @users = User.all
  end
end

# app/views/users/index.html.erb
<h1>Users</h1>
<% @users.each do |user| %>
  <p><%= user.email %></p>
<% end %>

Ruby Basics

Classes and object-oriented programming concepts, modules for namespacing and mixing in behavior, blocks and yield for creating reusable code segments, and understanding of Ruby's dynamic and duck typing.

Example:

class Animal
  def speak
    raise NotImplementedError, "Subclass must implement abstract method"
  end
end

class Dog < Animal
  def speak
    "Woof!"
  end
end

module Swimmable
  def swim
    "I'm swimming!"
  end
end

class Duck < Animal
  include Swimmable
  
  def speak
    "Quack!"
  end
end

ActiveRecord Basics

ORM (Object-Relational Mapping) concept, basic CRUD operations using ActiveRecord methods, and understanding of database tables and model relationships.

Example:

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

# In Rails console
user = User.create(name: "John Doe", email: "john@example.com")
User.find_by(name: "John Doe")
user.update(email: "johndoe@example.com")
user.destroy

RESTful Routes

Understanding of REST (Representational State Transfer) principles, seven standard RESTful actions (index, show, new, create, edit, update, destroy), and implementing RESTful routes in Rails using resources in routes.rb.

Example:

# config/routes.rb
Rails.application.routes.draw do
  resources :users
end

Rails Generators

Using built-in generators for models, controllers, and views, understanding the files created by each generator, and customizing generator templates for project-specific needs.

Example:

# Terminal commands
rails generate model User name:string email:string
rails generate controller Users index show

Migrations

Creating and running database migrations, adding, removing, and modifying database columns, and understanding of migration versioning and rollbacks.

Example:

class AddAgeToUsers < ActiveRecord::Migration[6.1]
  def change
    add_column :users, :age, :integer
  end
end

CRUD Operations

Implementing Create, Read, Update, Delete functionality in controllers, building forms for data input and editing, and displaying data in views.

Example:

class UsersController < ApplicationController
  def create
    @user = User.new(user_params)
    if @user.save
      redirect_to @user, notice: 'User was successfully created.'
    else
      render :new
    end
  end

  private

  def user_params
    params.require(:user).permit(:name, :email)
  end
end

Basic HTML and CSS

Writing semantic HTML5, styling with CSS, including flexbox and grid layouts, and understanding of responsive design principles.

Example:

<!-- app/views/layouts/application.html.erb -->
<!DOCTYPE html>
<html>
  <head>
    <title>My Rails App</title>
    <%= csrf_meta_tags %>
    <%= csp_meta_tag %>
    <%= stylesheet_link_tag 'application', media: 'all', 'data-turbolinks-track': 'reload' %>
  </head>
  <body>
    <%= yield %>
  </body>
</html>

/* app/assets/stylesheets/application.css */
.container {
  display: flex;
  flex-direction: column;
  max-width: 800px;
  margin: 0 auto;
}

Git Basics

Basic version control concepts, committing changes, creating branches, and merging, and collaborating with others using pull requests.

Example:

# Terminal commands
git init
git add .
git commit -m "Initial commit"
git branch feature-branch
git checkout feature-branch
git merge feature-branch

Rails Console

Interacting with your Rails application from the command line, testing model associations and queries, and debugging and data manipulation in development.

Example:

# In Rails console
User.count
User.where(age: 18..30).pluck(:name)
User.find(1).update(email: "newemail@example.com")

Mid-level Rails Developer

ActiveRecord Associations and Validations

Implementing complex associations (has_many :through, polymorphic associations), custom validation methods and error messages, callbacks for automating model-related actions, and eager loading to solve N+1 query problems.

Example:

# app/models/user.rb
class User < ApplicationRecord
  has_many :posts
  has_many :comments, through: :posts
  has_one :profile

  validates :email, presence: true, uniqueness: true
  validates :username, length: { in: 3..20 }

  before_save :normalize_email

  private

  def normalize_email
    self.email = email.downcase
  end
end

# app/models/post.rb
class Post < ApplicationRecord
  belongs_to :user
  has_many :comments

  # Eager loading example
  scope :with_user_and_comments, -> { includes(:user, :comments) }
end

Authentication

Implementing user authentication systems, understanding of sessions and cookies, customizing Devise views and controllers, and implementing alternative authentication strategies (OAuth, JWT).

Example using Devise:

# Gemfile
gem 'devise'

# Terminal
rails generate devise:install
rails generate devise User

# app/models/user.rb
class User < ApplicationRecord
  devise :database_authenticatable, :registerable,
         :recoverable, :rememberable, :validatable,
         :confirmable, :lockable, :timeoutable, :trackable
end

# app/controllers/application_controller.rb
class ApplicationController < ActionController::Base
  before_action :authenticate_user!
end

Authorization

Defining and managing user roles and permissions, implementing access control in controllers and views, writing and organizing authorization policies, and handling authorization failures gracefully.

Example using Pundit:

# Gemfile
gem 'pundit'

# app/policies/post_policy.rb
class PostPolicy < ApplicationPolicy
  def update?
    user.admin? || record.user == user
  end
end

# app/controllers/posts_controller.rb
class PostsController < ApplicationController
  def update
    @post = Post.find(params[:id])
    authorize @post
    if @post.update(post_params)
      redirect_to @post, notice: 'Post updated successfully.'
    else
      render :edit
    end
  end
end

Asset Pipeline

Understanding asset compilation and fingerprinting, managing JavaScript and CSS dependencies, configuring asset precompilation for production, and integrating with modern front-end build tools (Webpack, esbuild).

Example:

# config/initializers/assets.rb
Rails.application.config.assets.version = '1.0'
Rails.application.config.assets.precompile += %w( admin.js admin.css )

# app/assets/config/manifest.js
//= link_tree ../images
//= link_directory ../javascripts .js
//= link_directory ../stylesheets .css

Caching Strategies

Implementing page, action, and fragment caching, using low-level caching with Rails.cache, configuring and using Redis or Memcached as cache stores, and cache expiration and cache busting techniques.

Example:

# app/views/posts/index.html.erb
<% cache @posts do %>
  <% @posts.each do |post| %>
    <% cache post do %>
      <%= render post %>
    <% end %>
  <% end %>
<% end %>

# app/controllers/posts_controller.rb
class PostsController < ApplicationController
  def index
    @posts = Rails.cache.fetch('posts', expires_in: 1.hour) do
      Post.all.to_a
    end
  end
end

Background Jobs

Implementing asynchronous processing for time-consuming tasks, scheduling recurring jobs, monitoring and managing job queues, and handling job failures and retries.

Example using Sidekiq:

# Gemfile
gem 'sidekiq'

# app/jobs/send_welcome_email_job.rb
class SendWelcomeEmailJob < ApplicationJob
  queue_as :default

  def perform(user_id)
    user = User.find(user_id)
    UserMailer.welcome_email(user).deliver_now
  end
end

# app/controllers/users_controller.rb
class UsersController < ApplicationController
  def create
    @user = User.new(user_params)
    if @user.save
      SendWelcomeEmailJob.perform_later(@user.id)
      redirect_to @user, notice: 'User created successfully.'
    else
      render :new
    end
  end
end

Testing with RSpec

Writing unit tests for models, controllers, and helpers, implementing integration tests for full request/response cycles, using factories (e.g., FactoryBot) for test data generation, and measuring and improving test coverage.

Example:

# spec/models/user_spec.rb
require 'rails_helper'

RSpec.describe User, type: :model do
  it "is valid with valid attributes" do
    user = build(:user)
    expect(user).to be_valid
  end

  it "is not valid without an email" do
    user = build(:user, email: nil)
    expect(user).to_not be_valid
  end
end

# spec/requests/posts_spec.rb
RSpec.describe "Posts", type: :request do
  describe "GET /posts" do
    it "returns a successful response" do
      get posts_path
      expect(response).to have_http_status(:success)
    end
  end
end

JavaScript and jQuery Integration

Writing unobtrusive JavaScript in Rails applications, using jQuery for DOM manipulation and AJAX requests, implementing client-side form validations, and creating dynamic user interfaces with JavaScript.

Example:

// app/javascript/packs/application.js
import Rails from "@rails/ujs"
import Turbolinks from "turbolinks"
import * as ActiveStorage from "@rails/activestorage"
import "channels"

Rails.start()
Turbolinks.start()
ActiveStorage.start()

$(document).on('turbolinks:load', function() {
  $('#new-post-form').on('submit', function(e) {
    e.preventDefault();
    $.ajax({
      url: $(this).attr('action'),
      method: 'POST',
      data: $(this).serialize(),
      success: function(response) {
        $('#posts-container').append(response);
        $('#new-post-form')[0].reset();
      }
    });
  });
});

API Development and Consumption

Designing and implementing RESTful APIs, serializing data with libraries like Active Model Serializers, handling API versioning and documentation, and consuming external APIs using libraries like Faraday or HTTParty.

Example:

# app/controllers/api/v1/posts_controller.rb
module Api
  module V1
    class PostsController < ApplicationController
      def index
        @posts = Post.all
        render json: @posts
      end
    end
  end
end

# app/serializers/post_serializer.rb
class PostSerializer < ActiveModel::Serializer
  attributes :id, :title, :content
  belongs_to :user
end

# Consuming external API
require 'httparty'

response = HTTParty.get('https://api.example.com/posts')
posts = JSON.parse(response.body)

Database Indexing and Query Optimization

Identifying and creating appropriate database indexes, writing efficient ActiveRecord queries, using EXPLAIN to analyze query performance, and optimizing database schema for better performance.

Example:

# db/migrate/20230722000000_add_index_to_users_email.rb
class AddIndexToUsersEmail < ActiveRecord::Migration[6.1]
  def change
    add_index :users, :email
  end
end

# Optimized query

users = User.includes(:posts).where(active: true).order(:created_at)

# Using EXPLAIN
User.where(email: 'example@email.com').explain

Senior Rails Developer

Advanced ActiveRecord Queries

Writing complex SQL queries using Arel, optimizing database queries for large datasets, implementing advanced joins and subqueries, and using raw SQL when necessary for performance.

Example:

users_table = User.arel_table
posts_table = Post.arel_table

query = users_table.project(users_table[:id], users_table[:name])
  .join(posts_table).on(users_table[:id].eq(posts_table[:user_id]))
  .where(posts_table[:published_at].gt(1.month.ago))
  .group(users_table[:id])
  .having(posts_table[:id].count.gt(5))

User.find_by_sql(query.to_sql)

# Raw SQL for performance
User.find_by_sql(["
  SELECT users.*, COUNT(posts.id) as posts_count
  FROM users
  LEFT JOIN posts ON posts.user_id = users.id
  WHERE posts.published_at > ?
  GROUP BY users.id
  HAVING posts_count > 5
", 1.month.ago])

Service Objects and Design Patterns

Implementing service objects for complex business logic, applying design patterns (e.g., Decorator, Observer, Strategy), using presenters and view objects for cleaner views, and implementing the Repository pattern for data access.

Example:

# app/services/user_registration_service.rb
class UserRegistrationService
  def initialize(user_params)
    @user_params = user_params
  end

  def call
    user = User.new(@user_params)
    if user.save
      send_welcome_email(user)
      notify_admin(user)
      true
    else
      false
    end
  end

  private

  def send_welcome_email(user)
    UserMailer.welcome_email(user).deliver_later
  end

  def notify_admin(user)
    AdminNotifierJob.perform_later(user.id)
  end
end

# Decorator Pattern
class UserDecorator < SimpleDelegator
  def full_name
    "#{first_name} #{last_name}"
  end

  def member_since
    created_at.strftime("%B %Y")
  end
end

Performance Optimization Techniques

Profiling Rails applications (using tools like rack-mini-profiler), implementing Russian Doll caching, optimizing database queries and indexing, and improving application response time and reducing server load.

Example:

# config/environments/production.rb
Rails.application.configure do
  config.cache_classes = true
  config.eager_load = true
  config.consider_all_requests_local = false
  config.action_controller.perform_caching = true
  config.public_file_server.enabled = true
  config.assets.compile = false
  config.active_record.dump_schema_after_migration = false
end

# Russian Doll Caching
# app/views/posts/index.html.erb
<% cache @posts do %>
  <% @posts.each do |post| %>
    <% cache post do %>
      <%= render partial: 'post', locals: { post: post } %>
    <% end %>
  <% end %>
<% end %>

Security Best Practices

Preventing common vulnerabilities (XSS, CSRF, SQL Injection), implementing proper authentication and authorization, securing APIs with rate limiting and token authentication, and conducting security audits and penetration testing.

Example:

# config/initializers/content_security_policy.rb
Rails.application.config.content_security_policy do |policy|
  policy.default_src :self, :https
  policy.font_src    :self, :https, :data
  policy.img_src     :self, :https, :data
  policy.object_src  :none
  policy.script_src  :self, :https
  policy.style_src   :self, :https
  policy.connect_src :self, :https, 'http://localhost:3035', 'ws://localhost:3035'
end

# app/controllers/application_controller.rb
class ApplicationController < ActionController::Base
  protect_from_forgery with: :exception
  before_action :set_csrf_cookie

  private

  def set_csrf_cookie
    cookies['CSRF-TOKEN'] = form_authenticity_token
  end
end

Scaling Rails Applications

Implementing horizontal and vertical scaling strategies, using load balancers and reverse proxies, optimizing database performance for high traffic, and implementing caching at various levels (CDN, application, database).

Example:

# config/puma.rb
workers ENV.fetch("WEB_CONCURRENCY") { 2 }
threads_count = ENV.fetch("RAILS_MAX_THREADS") { 5 }
threads threads_count, threads_count

preload_app!

rackup      DefaultRackup
port        ENV.fetch("PORT") { 3000 }
environment ENV.fetch("RAILS_ENV") { "development" }

on_worker_boot do
  ActiveRecord::Base.establish_connection
end

# config/initializers/rack_attack.rb
class Rack::Attack
  throttle('req/ip', limit: 300, period: 5.minutes) do |req|
    req.ip
  end
end

Advanced Testing

Writing comprehensive test suites with RSpec, implementing behavior-driven development (BDD) with Cucumber, using mocks, stubs, and doubles for isolated unit testing, and implementing continuous integration and automated testing pipelines.

Example:

# spec/system/user_signs_up_spec.rb
require 'rails_helper'

RSpec.describe 'User signs up', type: :system do
  before do
    driven_by(:selenium_chrome_headless)
  end

  it 'allows a user to sign up' do
    visit new_user_registration_path
    fill_in 'Email', with: 'test@example.com'
    fill_in 'Password', with: 'password'
    fill_in 'Password confirmation', with: 'password'
    click_button 'Sign up'

    expect(page).to have_content 'Welcome! You have signed up successfully.'
    expect(User.last.email).to eq 'test@example.com'
  end
end

# spec/support/capybara.rb
Capybara.register_driver :selenium_chrome_headless do |app|
  options = Selenium::WebDriver::Chrome::Options.new
  options.add_argument('--headless')
  options.add_argument('--disable-gpu')
  options.add_argument('--no-sandbox')
  Capybara::Selenium::Driver.new(app, browser: :chrome, options: options)
end

Continuous Integration/Continuous Deployment (CI/CD)

Setting up CI/CD pipelines (e.g., Jenkins, GitLab CI, GitHub Actions), implementing automated testing and code quality checks, managing different deployment environments (staging, production), and implementing zero-downtime deployments.

Example:

# .gitlab-ci.yml
stages:
  - test
  - deploy

rspec:
  stage: test
  script:
    - bundle install
    - bundle exec rspec

rubocop:
  stage: test
  script:
    - bundle exec rubocop

deploy_production:
  stage: deploy
  script:
    - bundle exec cap production deploy
  only:
    - main

Refactoring and Code Organization

Identifying and refactoring code smells, applying SOLID principles to Rails applications, organizing large Rails applications (e.g., using engines), and implementing domain-driven design concepts in Rails.

Example:

# Before refactoring
class User < ApplicationRecord
  def full_name
    "#{first_name} #{last_name}"
  end

  def send_welcome_email
    UserMailer.welcome_email(self).deliver_now
  end

  def calculate_age
    ((Time.zone.now - birthdate.to_time) / 1.year.seconds).floor
  end
end

# After refactoring
class User < ApplicationRecord
  include NameConcern
  include EmailConcern
  include AgeConcern
end

module NameConcern
  extend ActiveSupport::Concern

  def full_name
    "#{first_name} #{last_name}"
  end
end

module EmailConcern
  extend ActiveSupport::Concern

  def send_welcome_email
    UserMailer.welcome_email(self).deliver_later
  end
end

module AgeConcern
  extend ActiveSupport::Concern

  def calculate_age
    ((Time.zone.now - birthdate.to_time) / 1.year.seconds).floor
  end
end

WebSockets and Action Cable

Implementing real-time features with Action Cable, scaling WebSocket connections, integrating WebSockets with background jobs, and securing WebSocket connections.

Example:

# app/channels/chat_channel.rb
class ChatChannel < ApplicationCable::Channel
  def subscribed
    stream_from "chat_#{params[:room_id]}"
  end

  def receive(data)
    ActionCable.server.broadcast("chat_#{params[:room_id]}", data)
  end
end

# app/javascript/channels/chat_channel.js
import consumer from "./consumer"

consumer.subscriptions.create({ channel: "ChatChannel", room_id: 1 }, {
  received(data) {
    this.appendLine(data)
  },

  appendLine(data) {
    const html = this.createLine(data)
    const element = document.querySelector("[data-chat-room='1']")
    element.insertAdjacentHTML("beforeend", html)
  },

  createLine(data) {
    return `
      <div class="message">
        <span class="message__user">${data["user"]}: </span>
        <span class="message__text">${data["message"]}</span>
      </div>
    `
  }
})

Internationalization (i18n) and Localization

Implementing multi-language support in Rails applications, managing translations and locales, handling date, time, and number formatting for different locales, and implementing right-to-left (RTL) support for applicable languages.

Example:

# config/application.rb
module YourApp
  class Application < Rails::Application
    config.i18n.load_path += Dir[Rails.root.join('config', 'locales', '**', '*.{rb,yml}')]
    config.i18n.available_locales = [:en, :es, :fr]
    config.i18n.default_locale = :en
  end
end

# config/locales/en.yml
en:
  hello: "Hello"
  welcome_message: "Welcome to our site, %{name}!"
  date:
    formats:
      default: "%Y-%m-%d"
      long: "%B %d, %Y"

# app/controllers/application_controller.rb
class ApplicationController < ActionController::Base
  before_action :set_locale

  def set_locale
    I18n.locale = params[:locale] || I18n.default_locale
  end
end

# app/views/welcome/index.html.erb
<h1><%= t('hello') %></h1>
<p><%= t('welcome_message', name: current_user.name) %></p>
<p><%= l(Date.today, format: :long) %></p>

Principal Rails Developer

System Architecture Design

Designing scalable and maintainable system architectures, making strategic technology choices for large-scale applications, balancing trade-offs between different architectural approaches, and implementing patterns like CQRS (Command Query Responsibility Segregation) and Event Sourcing.

Example of a modular monolith architecture:

# config/application.rb
module MyLargeApp
  class Application < Rails::Application
    config.autoload_paths += %W(#{config.root}/app/services)
    config.autoload_paths += Dir["#{config.root}/app/modules/**/"]
  end
end

# app/modules/user_management/app/models/user_management/user.rb
module UserManagement
  class User < ApplicationRecord
    # User model implementation
  end
end

# app/modules/billing/app/services/billing/invoice_service.rb
module Billing
  class InvoiceService
    def generate_invoice(user)
      # Invoice generation logic
    end
  end
end

Microservices Architecture

Designing and implementing microservices-based systems, managing inter-service communication (e.g., REST, gRPC, message queues), implementing service discovery and API gateways, and ensuring data consistency across microservices.

Example of a service discovery setup using Consul:

# Gemfile
gem 'diplomat'

# config/initializers/consul.rb
Diplomat.configure do |config|
  config.url = 'http://localhost:8500'
end

# app/services/user_service.rb
class UserService
  def fetch_user(id)
    user_service_url = Diplomat::Service.get('user-service')
    response = HTTP.get("#{user_service_url}/users/#{id}")
    JSON.parse(response.body)
  end
end

Event-driven Architecture

Designing systems using event-driven principles, implementing message brokers (e.g., RabbitMQ, Apache Kafka), ensuring event consistency and handling failures, and implementing event sourcing for complex business domains.

Example using Apache Kafka with ruby-kafka gem:

# Gemfile
gem 'ruby-kafka'

# config/initializers/kafka_producer.rb
KAFKA_PRODUCER = Kafka.new(seed_brokers: ['localhost:9092'])

# app/services/order_service.rb
class OrderService
  def create_order(user_id, items)
    order = Order.create!(user_id: user_id, items: items)
    KAFKA_PRODUCER.deliver_message({ order_id: order.id }.to_json, topic: 'orders')
    order
  end
end

# app/workers/order_processor.rb
class OrderProcessor
  def process
    consumer = KAFKA_PRODUCER.consumer(group_id: 'order_processors')
    consumer.subscribe('orders')
    consumer.each_message do |message|
      order_data = JSON.parse(message.value)
      process_order(order_data['order_id'])
    end
  end

  private

  def process_order(order_id)
    # Order processing logic
  end
end

Domain-Driven Design (DDD)

Applying DDD principles to complex Rails applications, defining bounded contexts and aggregates, implementing ubiquitous language in code and communication, and designing rich domain models and separating domain logic from infrastructure.

Example of a bounded context for an e-commerce application:

# app/bounded_contexts/catalog/app/models/catalog/product.rb
module Catalog
  class Product < ApplicationRecord
    # Product model specific to the Catalog context
  end
end

# app/bounded_contexts/ordering/app/models/ordering/order.rb
module Ordering
  class Order < ApplicationRecord
    # Order model specific to the Ordering context
  end
end

# app/bounded_contexts/shipping/app/services/shipping/shipment_service.rb
module Shipping
  class ShipmentService
    def create_shipment(order)
      # Shipment creation logic
    end
  end
end

Database Sharding and Replication

Implementing database sharding for horizontal scalability, setting up and managing database replication, ensuring data consistency across shards and replicas, and optimizing query routing and execution in sharded environments.

Example using Octopus gem for database sharding:

# Gemfile
gem 'ar-octopus'

# config/shards.yml
octopus:
  environments:
    - production
  production:
    shards:
      shard1:
        adapter: postgresql
        host: shard1.example.com
        database
        database: myapp_shard1
      shard2:
        adapter: postgresql
        host: shard2.example.com
        database: myapp_shard2

# app/models/user.rb
class User < ApplicationRecord
  octopus_establish_connection(:production)
  use_octopus_for_sharding

  def self.shard_for_user(user_id)
    "shard#{user_id % 2 + 1}"
  end
end

# Usage
User.using(User.shard_for_user(user_id)).find(user_id)

Distributed Systems and Eventual Consistency

Designing systems that maintain consistency in distributed environments, implementing conflict resolution strategies, understanding and applying CAP theorem principles, and implementing distributed caching and state management.

Example of implementing a distributed cache with Redis:

# Gemfile
gem 'redis'
gem 'connection_pool'

# config/initializers/redis.rb
REDIS = ConnectionPool.new(size: 5, timeout: 5) { Redis.new(url: ENV['REDIS_URL']) }

# app/models/concerns/cacheable.rb
module Cacheable
  extend ActiveSupport::Concern

  class_methods do
    def fetch_with_cache(id)
      REDIS.with do |conn|
        cached = conn.get("#{self.name.downcase}:#{id}")
        return JSON.parse(cached) if cached

        record = find(id)
        conn.set("#{self.name.downcase}:#{id}", record.to_json)
        record
      end
    end
  end
end

# Usage
class Product < ApplicationRecord
  include Cacheable
end

product = Product.fetch_with_cache(1)

Cloud Infrastructure (e.g., AWS, GCP, Azure)

Architecting cloud-native Rails applications, implementing auto-scaling and load balancing, designing for high availability and disaster recovery, and optimizing cloud resource usage and costs.

Example of setting up AWS resources using Terraform:

# main.tf
provider "aws" {
  region = "us-west-2"
}

resource "aws_instance" "web" {
  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = "t2.micro"
  
  tags = {
    Name = "WebServer"
  }
}

resource "aws_s3_bucket" "app_assets" {
  bucket = "my-app-assets"
  acl    = "private"

  versioning {
    enabled = true
  }
}

Containerization and Orchestration (e.g., Docker, Kubernetes)

Containerizing Rails applications and services, designing and managing Kubernetes clusters, implementing CI/CD pipelines for containerized applications, and ensuring security and monitoring in container environments.

Example Dockerfile for a Rails application:

# Dockerfile
FROM ruby:3.0.0

RUN apt-get update -qq && apt-get install -y nodejs postgresql-client
WORKDIR /myapp
COPY Gemfile /myapp/Gemfile
COPY Gemfile.lock /myapp/Gemfile.lock
RUN bundle install

COPY . /myapp

EXPOSE 3000
CMD ["rails", "server", "-b", "0.0.0.0"]

Example Kubernetes deployment:

# kubernetes/deployment.yml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
      - name: myapp
        image: myapp:latest
        ports:
        - containerPort: 3000

Machine Learning Integration in Rails

Integrating machine learning models into Rails applications, implementing real-time prediction services, managing and updating ML models in production, and ensuring scalability and performance of ML-powered features.

Example of integrating a machine learning model using Ruby's Torch.rb:

# Gemfile
gem 'torch-rb'

# app/services/product_recommender.rb
class ProductRecommender
  def initialize
    @model = Torch.load('lib/models/product_recommender.pt')
    @model.eval
  end

  def recommend_products(user_id)
    user_tensor = Torch.tensor([[user_id]])
    output = @model.forward(user_tensor)
    product_ids = output.argmax(dim: 1).to_a
    Product.where(id: product_ids)
  end
end

# Usage
recommender = ProductRecommender.new
recommended_products = recommender.recommend_products(current_user.id)

Technical Leadership and Mentoring

Providing technical vision and strategy for large projects or organizations, mentoring and developing senior developers, conducting architecture reviews and setting coding standards, balancing technical debt with feature development, and communicating complex technical concepts to non-technical stakeholders.

Example of a code review checklist:

CODE_REVIEW_CHECKLIST = [
  'Does the code follow our style guide?',
  'Are there appropriate tests for the new functionality?',
  'Is the code DRY (Don't Repeat Yourself)?',
  'Are edge cases handled appropriately?',
  'Is there proper error handling and logging?',
  'Is the code performant and scalable?',
  'Are there any potential security issues?',
  'Is the documentation clear and up-to-date?'
]

Example of a technical decision document template:

TECH_DECISION_TEMPLATE = <<~TEMPLATE
  # Technical Decision: [Title]

  ## Context
  [Describe the current situation and why a decision is needed]

  ## Options Considered
  1. [Option 1]
  2. [Option 2]
  3. [Option 3]

  ## Decision
  [State the chosen option and rationale]

  ## Consequences
  [Describe the impact of this decision, both positive and negative]

  ## Action Items
  [List any follow-up tasks or considerations]
TEMPLATE

# Usage in a Rails application
class TechnicalDecisionController < ApplicationController
  def new
    @decision_template = TECH_DECISION_TEMPLATE
  end

  def create
    # Logic to save the technical decision document
  end
end