Hot Take: Ruby on Rails 8.0 Is Dead for Startups Using Go 1.24 and Rust 1.85

# app/controllers/api/v1/users_controller.rb
# Rails 8.0 user registration endpoint with full error handling
module Api
  module V1
    class UsersController < ApplicationController
      skip_before_action :verify_authenticity_token, only: [:create]
      before_action :set_user, only: [:show]

      # POST /api/v1/users
      def create
        @user = User.new(user_params)

        if @user.save
          # Generate JWT token for session (Rails 8.0 default uses ActiveSupport::MessageEncryptor)
          token = generate_auth_token(@user.id)
          render json: {
            status: 'success',
            data: {
              user: user_serializer(@user),
              token: token
            }
          }, status: :created
        else
          # Rails 8.0 returns 422 Unprocessable Entity by default for validation errors
          render json: {
            status: 'error',
            errors: @user.errors.full_messages
          }, status: :unprocessable_entity
        end
      rescue ActiveRecord::RecordNotUnique => e
        # Handle duplicate email/phone errors
        render json: {
          status: 'error',
          errors: ['Email or phone number already registered']
        }, status: :conflict
      rescue StandardError => e
        # Catch-all for unexpected errors, log to Rails.logger (8.0 defaults to structured JSON logging)
        Rails.logger.error("User creation failed: #{e.message}", { backtrace: e.backtrace.first(10) })
        render json: {
          status: 'error',
          errors: ['Internal server error']
        }, status: :internal_server_error
      end

      # GET /api/v1/users/:id
      def show
        render json: {
          status: 'success',
          data: user_serializer(@user)
        }, status: :ok
      rescue ActiveRecord::RecordNotFound => e
        render json: {
          status: 'error',
          errors: ['User not found']
        }, status: :not_found
      end

      private

      def set_user
        @user = User.find(params[:id])
      end

      def user_params
        params.require(:user).permit(:email, :password, :password_confirmation, :phone)
      end

      def generate_auth_token(user_id)
        encryptor = ActiveSupport::MessageEncryptor.new(Rails.application.credentials.secret_key_base.byteslice(0..31))
        encryptor.encrypt_and_sign({ user_id: user_id, exp: 24.hours.from_now.to_i })
      end

      def user_serializer(user)
        {
          id: user.id,
          email: user.email,
          phone: user.phone,
          created_at: user.created_at.iso8601
        }
      end
    end
  end
end

// main.go
// Go 1.24 user registration API with full error handling, equivalent to Rails 8.0 example
package main

import (
    "context"
    "crypto/rand"
    "encoding/hex"
    "errors"
    "log/slog"
    "net/http"
    "os"
    "time"

    "github.com/gin-gonic/gin"
    "github.com/golang-jwt/jwt/v5"
    "golang.org/x/crypto/bcrypt"
    "gorm.io/driver/postgres"
    "gorm.io/gorm"
)

// User model matching Rails 8.0 User schema
type User struct {
    ID        uint      `json:"id" gorm:"primaryKey"`
    Email     string    `json:"email" gorm:"uniqueIndex;not null"`
    Phone     string    `json:"phone" gorm:"uniqueIndex"`
    Password  string    `json:"-" gorm:"not null"` // Never serialize password
    CreatedAt time.Time `json:"created_at"`
    UpdatedAt time.Time `json:"updated_at"`
}

// SignupRequest matches Rails user_params
type SignupRequest struct {
    Email                string `json:"email" binding:"required,email"`
    Password             string `json:"password" binding:"required,min=8"`
    PasswordConfirmation string `json:"password_confirmation" binding:"required,eqfield=Password"`
    Phone                string `json:"phone" binding:"omitempty,e164"`
}

// AuthResponse matches Rails response structure
type AuthResponse struct {
    Status string      `json:"status"`
    Data   interface{} `json:"data,omitempty"`
    Errors []string    `json:"errors,omitempty"`
}

var (
    db     *gorm.DB
    logger *slog.Logger
    jwtKey []byte
)

func init() {
    // Initialize structured logger (Go 1.24 slog is standard library)
    logger = slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelInfo}))

    // Load JWT secret from environment (matches Rails credentials)
    jwtSecret := os.Getenv("JWT_SECRET")
    if jwtSecret == "" {
        logger.Error("JWT_SECRET environment variable not set")
        os.Exit(1)
    }
    jwtKey = []byte(jwtSecret)

    // Initialize GORM with Postgres (matches Rails ActiveRecord)
    dsn := os.Getenv("DATABASE_URL")
    if dsn == "" {
        dsn = "host=localhost user=postgres password=postgres dbname=startup_db port=5432 sslmode=disable"
    }
    var err error
    db, err = gorm.Open(postgres.Open(dsn), &gorm.Config{})
    if err != nil {
        logger.Error("Failed to connect to database", "error", err)
        os.Exit(1)
    }

    // Auto-migrate schema (matches Rails db:migrate)
    err = db.AutoMigrate(&User{})
    if err != nil {
        logger.Error("Failed to migrate database", "error", err)
        os.Exit(1)
    }
}

func generateAuthToken(userID uint) (string, error) {
    token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
        "user_id": userID,
        "exp":     time.Now().Add(24 * time.Hour).Unix(),
    })
    return token.SignedString(jwtKey)
}

func signupHandler(c *gin.Context) {
    var req SignupRequest
    if err := c.ShouldBindJSON(&req); err != nil {
        c.JSON(http.StatusBadRequest, AuthResponse{
            Status: "error",
            Errors: []string{"Invalid request: " + err.Error()},
        })
        return
    }

    // Hash password with bcrypt (matches Rails has_secure_password default cost)
    hashedPassword, err := bcrypt.GenerateFromPassword([]byte(req.Password), bcrypt.DefaultCost)
    if err != nil {
        logger.Error("Failed to hash password", "error", err)
        c.JSON(http.StatusInternalServerError, AuthResponse{
            Status: "error",
            Errors: []string{"Internal server error"},
        })
        return
    }

    user := User{
        Email:    req.Email,
        Phone:    req.Phone,
        Password: string(hashedPassword),
    }

    // Create user in DB
    result := db.Create(&user)
    if result.Error != nil {
        // Check for unique constraint violation (matches Rails RecordNotUnique)
        if errors.Is(result.Error, gorm.ErrDuplicatedKey) {
            c.JSON(http.StatusConflict, AuthResponse{
                Status: "error",
                Errors: []string{"Email or phone number already registered"},
            })
            return
        }
        logger.Error("Failed to create user", "error", result.Error)
        c.JSON(http.StatusInternalServerError, AuthResponse{
            Status: "error",
            Errors: []string{"Internal server error"},
        })
        return
    }

    // Generate JWT token
    token, err := generateAuthToken(user.ID)
    if err != nil {
        logger.Error("Failed to generate auth token", "error", err)
        c.JSON(http.StatusInternalServerError, AuthResponse{
            Status: "error",
            Errors: []string{"Internal server error"},
        })
        return
    }

    c.JSON(http.StatusCreated, AuthResponse{
        Status: "success",
        Data: gin.H{
            "user": gin.H{
                "id":         user.ID,
                "email":      user.Email,
                "phone":      user.Phone,
                "created_at": user.CreatedAt.Format(time.RFC3339),
            },
            "token": token,
        },
    })
}

func main() {
    r := gin.Default()

    // Health check endpoint
    r.GET("/health", func(c *gin.Context) {
        c.JSON(http.StatusOK, gin.H{"status": "healthy"})
    })

    // API routes
    v1 := r.Group("/api/v1")
    {
        v1.POST("/users", signupHandler)
    }

    logger.Info("Starting Go 1.24 server on :8080")
    if err := r.Run(":8080"); err != nil {
        logger.Error("Server failed to start", "error", err)
        os.Exit(1)
    }
}

// src/main.rs
// Rust 1.85 user registration API with full error handling, matching Go/Rails examples
use axum::{
    extract::Json,
    http::StatusCode,
    response::Json as ResponseJson,
    routing::post,
    Router,
};
use serde::{Deserialize, Serialize};
use sqlx::{postgres::PgPoolOptions, PgPool};
use bcrypt::{hash, verify, DEFAULT_COST};
use jsonwebtoken::{encode, Header, EncodingKey, Errors as JwtError};
use std::{env, time::{SystemTime, UNIX_EPOCH}};
use dotenvy::dotenv;
use tracing::{error, info};
use tracing_subscriber::{fmt, EnvFilter};

// User model matching Rails/Go schemas
#[derive(Debug, Serialize, Deserialize, sqlx::FromRow)]
struct User {
    id: i32,
    email: String,
    phone: Option,
    password: String,
    created_at: chrono::DateTime,
}

// Signup request matching Rails user_params and Go SignupRequest
#[derive(Debug, Deserialize)]
struct SignupRequest {
    email: String,
    password: String,
    password_confirmation: String,
    phone: Option,
}

// API response matching Rails/Go response structure
#[derive(Debug, Serialize)]
struct ApiResponse {
    status: String,
    data: Option,
    errors: Option>,
}

// JWT claims struct
#[derive(Debug, Serialize, Deserialize)]
struct Claims {
    user_id: i32,
    exp: usize,
}

// App state holding DB pool and JWT secret
struct AppState {
    db: PgPool,
    jwt_secret: String,
    jwt_encoding_key: EncodingKey,
}

#[tokio::main]
async fn main() -> Result<(), Box> {
    // Load .env file (matches Rails credentials/Go env vars)
    dotenv().ok();

    // Initialize tracing (Rust 1.85 uses tracing-subscriber for structured logs)
    tracing_subscriber::fmt()
        .with_env_filter(EnvFilter::from_default_env())
        .init();

    // Load JWT secret
    let jwt_secret = env::var("JWT_SECRET").expect("JWT_SECRET must be set");
    let jwt_encoding_key = EncodingKey::from_secret(jwt_secret.as_bytes());

    // Initialize Postgres pool (matches Rails ActiveRecord/Gorm)
    let database_url = env::var("DATABASE_URL").unwrap_or_else(|_| {
        "postgres://postgres:postgres@localhost:5432/startup_db".to_string()
    });
    let db_pool = PgPoolOptions::new()
        .max_connections(10)
        .connect(&database_url)
        .await?;

    // Run migrations (matches Rails db:migrate/Gorm AutoMigrate)
    sqlx::migrate!("./migrations").run(&db_pool).await?;

    // Create app state
    let state = AppState {
        db: db_pool,
        jwt_secret,
        jwt_encoding_key,
    };

    // Build router
    let app = Router::new()
        .route("/api/v1/users", post(signup_handler))
        .route("/health", axum::routing::get(|| async { "healthy" }))
        .with_state(state);

    // Start server
    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await?;
    info!("Starting Rust 1.85 server on :3000");
    axum::serve(listener, app).await?;

    Ok(())
}

async fn signup_handler(
    state: axum::extract::State,
    Json(req): Json,
) -> (StatusCode, ResponseJson>) {
    // Validate password confirmation
    if req.password != req.password_confirmation {
        return (
            StatusCode::BAD_REQUEST,
            ResponseJson(ApiResponse {
                status: "error".to_string(),
                data: None,
                errors: Some(vec!["Password confirmation does not match".to_string()]),
            }),
        );
    }

    // Hash password with bcrypt (matches Rails/Go)
    let hashed_password = match hash(req.password.as_bytes(), DEFAULT_COST) {
        Ok(h) => h,
        Err(e) => {
            error!("Failed to hash password: {}", e);
            return (
                StatusCode::INTERNAL_SERVER_ERROR,
                ResponseJson(ApiResponse {
                    status: "error".to_string(),
                    data: None,
                    errors: Some(vec!["Internal server error".to_string()]),
                }),
            );
        }
    };

    // Insert user into DB
    let result = sqlx::query!(
        r#"
        INSERT INTO users (email, phone, password, created_at)
        VALUES ($1, $2, $3, NOW())
        RETURNING id, email, phone, created_at
        "#,
        req.email,
        req.phone,
        hashed_password
    )
    .fetch_one(&state.db)
    .await;

    let user = match result {
        Ok(row) => User {
            id: row.id,
            email: row.email,
            phone: row.phone,
            password: hashed_password.clone(),
            created_at: row.created_at,
        },
        Err(e) => {
            // Check for unique violation (matches Rails RecordNotUnique/Go ErrDuplicatedKey)
            if let sqlx::Error::Database(db_err) = &e {
                if db_err.code().as_deref() == Some("23505") { // Postgres unique violation code
                    return (
                        StatusCode::CONFLICT,
                        ResponseJson(ApiResponse {
                            status: "error".to_string(),
                            data: None,
                            errors: Some(vec!["Email or phone number already registered".to_string()]),
                        }),
                    );
                }
            }
            error!("Failed to create user: {}", e);
            return (
                StatusCode::INTERNAL_SERVER_ERROR,
                ResponseJson(ApiResponse {
                    status: "error".to_string(),
                    data: None,
                    errors: Some(vec!["Internal server error".to_string()]),
                }),
            );
        }
    };

    // Generate JWT token
    let expiration = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .expect("Time went backwards")
        .as_secs() + 86400; // 24 hours

    let claims = Claims {
        user_id: user.id,
        exp: expiration as usize,
    };

    let token = match encode(&Header::default(), &claims, &state.jwt_encoding_key) {
        Ok(t) => t,
        Err(e) => {
            error!("Failed to generate JWT: {}", e);
            return (
                StatusCode::INTERNAL_SERVER_ERROR,
                ResponseJson(ApiResponse {
                    status: "error".to_string(),
                    data: None,
                    errors: Some(vec!["Internal server error".to_string()]),
                }),
            );
        }
    };

    // Return success response
    (
        StatusCode::CREATED,
        ResponseJson(ApiResponse {
            status: "success".to_string(),
            data: Some(serde_json::json!({
                "user": {
                    "id": user.id,
                    "email": user.email,
                    "phone": user.phone,
                    "created_at": user.created_at.to_rfc3339(),
                },
                "token": token
            })),
            errors: None,
        }),
    )
}

// Stream user events from Postgres using iter + SQLx, zero allocation
func streamUserEvents(db *sqlx.DB, userID int) iter.Seq2[UserEvent, error] {
    return func(yield func(UserEvent, error) bool) {
        rows, err := db.Queryx("SELECT id, user_id, type, metadata, created_at FROM user_events WHERE user_id = $1", userID)
        if err != nil {
            yield(UserEvent{}, err)
            return
        }
        defer rows.Close()

        for rows.Next() {
            var event UserEvent
            if err := rows.StructScan(&event); err != nil {
                yield(event, err)
                return
            }
            if !yield(event, nil) {
                return
            }
        }
    }
}

// Usage: process 100k events without loading into memory
for event, err := range streamUserEvents(db, 123) {
    if err != nil {
        log.Printf("Error processing event: %v", err)
        continue
    }
    processEvent(event)
}

# Run cargo-machete to find and remove unused dependencies
$ cargo install cargo-machete
$ cargo machete --fix

# Example rust-analyzer output for dead code (runs in VS Code/Obsidian)
warning: unused function `old_user_migration`
  --> src/migrations.rs:42:10
   |
42 | pub fn old_user_migration() -> String {
   |          ^^^^^^^^^^^^^^^^^
   |
   = note: `#[warn(dead_code)]` on by default

// Define an asynq job for sending welcome emails
type WelcomeEmailJob struct {
    UserID int
}

func (j *WelcomeEmailJob) Process(ctx context.Context, task *asynq.Task) error {
    var user User
    db.First(&user, j.UserID)
    return sendWelcomeEmail(user.Email)
}

// Enqueue job in Go API handler
func signupHandler(c *gin.Context) {
    // ... create user ...
    client := asynq.NewClient(redis.Options{Addr: "localhost:6379"})
    defer client.Close()
    task := asynq.NewTask("welcome_email", WelcomeEmailJob{UserID: user.ID})
    client.Enqueue(task)
}