Comparison: Elixir 1.17 vs. Go 1.24 vs. Rust 1.95 for Real-Time Chat App Throughput and Fault Tolerance

# Elixir 1.17 Real-Time Chat Server with Supervision
# Dependencies: {:cowboy, "~> 2.12"}, {:jason, "~> 1.4"}, {:uuid, "~> 1.1"}
# Run with: mix run --no-halt

defmodule ChatServer.Application do
  @moduledoc "Supervised chat server application"
  use Application

  @impl true
  def start(_type, _args) do
    children = [
      # TCP listener for WebSocket connections
      {ChatServer.Listener, port: 4000},
      # Registry for active user connections
      {Registry, keys: :unique, name: ChatServer.ConnectionRegistry},
      # Supervisor for per-user connection processes
      {DynamicSupervisor, strategy: :one_for_one, name: ChatServer.ConnectionSupervisor}
    ]

    opts = [strategy: :one_for_one, name: ChatServer.Supervisor]
    Supervisor.start_link(children, opts)
  end
end

defmodule ChatServer.Listener do
  @moduledoc "Cowboy WebSocket listener setup"
  require Logger

  def start_link(opts) do
    port = Keyword.get(opts, :port, 4000)
    # Start Cowboy HTTP/WS listener
    {:ok, _pid} = :cowboy.start_clear(
      :chat_listener,
      [port: port],
      %{
        env: %{dispatch: :cowboy_router.compile([
          {"/", ChatServer.WebsocketHandler, []}
        ])}
      }
    )
    Logger.info("Chat listener started on port #{port}")
    # Return a supervised process that keeps the listener alive
    {:ok, self()}
  end
end

defmodule ChatServer.WebsocketHandler do
  @moduledoc "Handles individual WebSocket connections"
  require Logger
  alias ChatServer.{ConnectionRegistry, ConnectionSupervisor}

  def init(req, _opts) do
    # Upgrade HTTP request to WebSocket
    {:cowboy_websocket, req, %{user_id: nil, conn_pid: nil}}
  end

  def websocket_init(state) do
    # Register connection in registry
    user_id = UUID.uuid4()
    Registry.register(ConnectionRegistry, user_id, self())
    # Start dynamic connection process for fault isolation
    {:ok, pid} = DynamicSupervisor.start_child(
      ConnectionSupervisor,
      {ChatServer.Connection, user_id: user_id}
    )
    {:ok, %{state | user_id: user_id, conn_pid: pid}}
  end

  def websocket_handle({:text, msg}, state) do
    # Parse incoming message
    case Jason.decode(msg) do
      {:ok, %{"content" => content}} ->
        # Broadcast message to all connected users
        broadcast(content, state.user_id)
        {:reply, {:text, Jason.encode!(%{status: "ok"})}, state}
      {:error, err} ->
        Logger.error("Failed to parse message: #{inspect(err)}")
        {:reply, {:text, Jason.encode!(%{status: "error", reason: "invalid_json"})}, state}
    end
  end

  def websocket_handle(_data, state), do: {:ok, state}

  def websocket_info({:broadcast, content, sender_id}, state) do
    # Send broadcast message to this connection
    msg = Jason.encode!(%{sender: sender_id, content: content, timestamp: DateTime.utc_now()})
    {:reply, {:text, msg}, state}
  end

  def websocket_terminate(_reason, _req, state) do
    # Clean up connection on terminate
    Registry.unregister(ConnectionRegistry, state.user_id)
    Logger.info("User #{state.user_id} disconnected")
    :ok
  end

  defp broadcast(content, sender_id) do
    # Iterate all registered connections and send broadcast
    Registry.dispatch(ConnectionRegistry, :all, fn entries ->
      for {pid, _} <- entries do
        send(pid, {:broadcast, content, sender_id})
      end
    end)
  end
end

// Go 1.24 Real-Time Chat Server with Goroutine-Based Concurrency
// Dependencies: github.com/gorilla/websocket v1.5.0
// Build with: go build -o chat-server main.go
// Run with: ./chat-server -port 4000

package main

import (
    "context"
    "encoding/json"
    "flag"
    "fmt"
    "log"
    "net/http"
    "sync"
    "time"

    "github.com/gorilla/websocket"
)

var (
    upgrader = websocket.Upgrader{
        ReadBufferSize:  1024,
        WriteBufferSize: 1024,
        CheckOrigin: func(r *http.Request) bool {
            return true // Allow all origins for demo
        },
    }
    port    = flag.Int("port", 4000, "TCP port to listen on")
    clients = make(map[*websocket.Conn]string) // conn -> userID
    mu      sync.RWMutex
)

type ChatMessage struct {
    Sender    string `json:"sender"`
    Content   string `json:"content"`
    Timestamp string `json:"timestamp"`
}

type IncomingMessage struct {
    Content string `json:"content"`
}

func main() {
    flag.Parse()
    http.HandleFunc("/", handleWebSocket)
    log.Printf("Go chat server starting on port %d", *port)
    if err := http.ListenAndServe(fmt.Sprintf(":%d", *port), nil); err != nil {
        log.Fatalf("Failed to start server: %v", err)
    }
}

func handleWebSocket(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Printf("Failed to upgrade connection: %v", err)
        return
    }
    defer conn.Close()

    // Generate unique user ID
    userID := fmt.Sprintf("user-%d", time.Now().UnixNano())
    mu.Lock()
    clients[conn] = userID
    mu.Unlock()
    log.Printf("User %s connected, total clients: %d", userID, len(clients))

    // Start read pump in goroutine
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()
    go readPump(ctx, conn, userID)

    // Write pump blocks until connection closes
    writePump(ctx, conn, userID)
}

func readPump(ctx context.Context, conn *websocket.Conn, userID string) {
    defer func() {
        mu.Lock()
        delete(clients, conn)
        mu.Unlock()
        log.Printf("User %s disconnected, total clients: %d", userID, len(clients))
        conn.Close()
    }()

    conn.SetReadLimit(512)
    conn.SetReadDeadline(time.Now().Add(60 * time.Second))
    conn.SetPongHandler(func(string) error {
        conn.SetReadDeadline(time.Now().Add(60 * time.Second))
        return nil
    })

    for {
        select {
        case <-ctx.Done():
            return
        default:
            _, msg, err := conn.ReadMessage()
            if err != nil {
                if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway, websocket.CloseNormalClosure) {
                    log.Printf("Unexpected close error for %s: %v", userID, err)
                }
                return
            }

            var incoming IncomingMessage
            if err := json.Unmarshal(msg, &incoming); err != nil {
                log.Printf("Failed to parse message from %s: %v", userID, err)
                conn.WriteJSON(map[string]string{"status": "error", "reason": "invalid_json"})
                continue
            }

            // Broadcast message to all clients
            broadcast(incoming.Content, userID)
        }
    }
}

func writePump(ctx context.Context, conn *websocket.Conn, userID string) {
    ticker := time.NewTicker(54 * time.Second)
    defer ticker.Stop()

    for {
        select {
        case <-ctx.Done():
            return
        case <-ticker.C:
            // Send ping to keep connection alive
            conn.SetWriteDeadline(time.Now().Add(10 * time.Second))
            if err := conn.WriteMessage(websocket.PingMessage, nil); err != nil {
                return
            }
        }
    }
}

func broadcast(content, senderID string) {
    msg := ChatMessage{
        Sender:    senderID,
        Content:   content,
        Timestamp: time.Now().UTC().Format(time.RFC3339),
    }
    msgBytes, err := json.Marshal(msg)
    if err != nil {
        log.Printf("Failed to marshal broadcast message: %v", err)
        return
    }

    mu.RLock()
    defer mu.RUnlock()
    for conn := range clients {
        conn.SetWriteDeadline(time.Now().Add(10 * time.Second))
        if err := conn.WriteMessage(websocket.TextMessage, msgBytes); err != nil {
            log.Printf("Failed to write to client %s: %v", clients[conn], err)
        }
    }
}

// Rust 1.95 Real-Time Chat Server with Tokio Async Runtime
// Dependencies: tokio = { version = "1.38", features = ["full"] }, tungstenite = "0.21", serde = { version = "1.0", features = ["derive"] }, serde_json = "1.0"
// Build with: cargo build --release
// Run with: ./target/release/chat-server 4000

use std::collections::HashMap;
use std::sync::{Arc, Mutex};
use std::time::{SystemTime, UNIX_EPOCH};

use tokio::net::TcpListener;
use tokio::sync::broadcast;
use tungstenite::{Message, Utf8Bytes};
use serde::{Deserialize, Serialize};

type Clients = Arc>>>;

#[derive(Serialize, Deserialize)]
struct IncomingMessage {
    content: String,
}

#[derive(Serialize)]
struct ChatMessage {
    sender: String,
    content: String,
    timestamp: u64,
}

#[tokio::main]
async fn main() -> Result<(), Box> {
    let args: Vec = std::env::args().collect();
    let port = args.get(1).map(|s| s.parse::()).unwrap_or(Ok(4000))?;
    let listener = TcpListener::bind(format!("0.0.0.0:{}", port)).await?;
    println!("Rust chat server starting on port {}", port);

    let clients: Clients = Arc::new(Mutex::new(HashMap::new()));
    let (tx, _) = broadcast::channel(1000); // Broadcast channel for messages

    loop {
        let (stream, addr) = listener.accept().await?;
        println!("New connection from: {}", addr);

        let clients_clone = Arc::clone(&clients);
        let tx_clone = tx.clone();

        tokio::spawn(async move {
            match handle_connection(stream, clients_clone, tx_clone).await {
                Ok(_) => println!("Connection from {} closed", addr),
                Err(e) => eprintln!("Error handling connection from {}: {}", addr, e),
            }
        });
    }
}

async fn handle_connection(
    stream: tokio::net::TcpStream,
    clients: Clients,
    tx: broadcast::Sender,
) -> Result<(), Box> {
    let user_id = format!("user-{}", SystemTime::now().duration_since(UNIX_EPOCH)?.as_nanos());
    let mut ws_stream = tungstenite::accept_async(stream).await?;
    println!("User {} connected", user_id);

    // Add client to active connections
    let (client_tx, _) = broadcast::channel(100);
    clients.lock().unwrap().insert(user_id.clone(), client_tx.clone());

    // Subscribe to broadcast channel
    let mut rx = tx.subscribe();

    loop {
        tokio::select! {
            // Read incoming messages
            msg = ws_stream.next() => {
                match msg {
                    Some(Ok(Message::Text(text))) => {
                        let incoming: IncomingMessage = match serde_json::from_str(&text) {
                            Ok(msg) => msg,
                            Err(e) => {
                                eprintln!("Failed to parse message from {}: {}", user_id, e);
                                let error_msg = serde_json::json!({"status": "error", "reason": "invalid_json"});
                                ws_stream.send(Message::Text(Utf8Bytes::from(error_msg.to_string()))).await?;
                                continue;
                            }
                        };

                        // Create chat message and broadcast
                        let chat_msg = ChatMessage {
                            sender: user_id.clone(),
                            content: incoming.content,
                            timestamp: SystemTime::now().duration_since(UNIX_EPOCH)?.as_secs(),
                        };
                        let msg_json = serde_json::to_string(&chat_msg)?;
                        tx.send(msg_json.clone())?;
                    }
                    Some(Ok(Message::Close(_))) => {
                        println!("User {} sent close frame", user_id);
                        break;
                    }
                    Some(Err(e)) => {
                        eprintln!("WebSocket error for {}: {}", user_id, e);
                        break;
                    }
                    None => break,
                }
            }

            // Receive broadcast messages
            Ok(msg) = rx.recv() => {
                ws_stream.send(Message::Text(Utf8Bytes::from(msg))).await?;
            }
        }
    }

    // Clean up client on disconnect
    clients.lock().unwrap().remove(&user_id);
    println!("User {} disconnected", user_id);
    Ok(())
}

# Add to ChatServer.ConnectionSupervisor init
def init(_opts) do
  DynamicSupervisor.init(
    strategy: :one_for_one,
    max_restarts: 3,
    max_seconds: 5
  )
end

var bufferPool = sync.Pool{
    New: func() interface{} {
        return make([]byte, 1024)
    },
}

func readPump(ctx context.Context, conn *websocket.Conn, userID string) {
    // Get buffer from pool
    buf := bufferPool.Get().([]byte)
    defer bufferPool.Put(buf)

    for {
        // Read into pooled buffer
        _, err := conn.ReadMessageInto(buf)
        // ... rest of read logic
    }
}

// Replace shared clients map with broadcast channel
let (tx, _) = broadcast::channel(1000);

// Each connection subscribes to the channel
let mut rx = tx.subscribe();

// Broadcast messages by sending to the channel
tx.send(msg_json)?;