Why Companies Are Betting on Rust for Production Systems

fn main() {
    let data = vec![1, 2, 3];
    let reference = &data;

    drop(data); // Compile error: cannot drop while borrowed
    println!("{:?}", reference);
}

// This high-level iterator chain...
let sum: i64 = numbers
    .iter()
    .filter(|n| **n > 0)
    .map(|n| n * 2)
    .sum();

// ...compiles to the same assembly as this manual loop:
let mut sum: i64 = 0;
for n in &numbers {
    if *n > 0 {
        sum += n * 2;
    }
}

use std::thread;

fn main() {
    let mut data = vec![1, 2, 3];

    // This won't compile — can't mutate from multiple threads
    thread::spawn(|| {
        data.push(4); // Error: closure may outlive the current function
    });

    data.push(5);
}

use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    let data = Arc::new(Mutex::new(vec![1, 2, 3]));

    let data_clone = Arc::clone(&data);
    let handle = thread::spawn(move || {
        data_clone.lock().unwrap().push(4);
    });

    data.lock().unwrap().push(5);
    handle.join().unwrap();
}

Go service under load:
  p50: 2ms
  p99: 15ms
  p99.9: 200ms  ← GC pause

Rust service under load:
  p50: 1ms
  p99: 3ms
  p99.9: 5ms    ← No GC, predictable

use pingora::prelude::*;

pub struct MyProxy;

#[async_trait]
impl ProxyHttp for MyProxy {
    type CTX = ();

    fn new_ctx(&self) -> Self::CTX {}

    async fn upstream_peer(
        &self,
        session: &mut Session,
        _ctx: &mut Self::CTX,
    ) -> Result<Box<HttpPeer>> {
        let peer = HttpPeer::new(("backend.example.com", 443), true, "backend.example.com".into());
        Ok(Box::new(peer))
    }
}

use clap::Parser;
use std::fs;

#[derive(Parser)]
#[command(name = "wordcount", about = "Count words in files")]
struct Args {
    /// Files to process
    #[arg(required = true)]
    files: Vec<String>,

    /// Count lines instead of words
    #[arg(short, long)]
    lines: bool,
}

fn main() {
    let args = Args::parse();

    for file in &args.files {
        let content = fs::read_to_string(file).expect("Failed to read file");
        let count = if args.lines {
            content.lines().count()
        } else {
            content.split_whitespace().count()
        };
        println!("{file}: {count}");
    }
}

use axum::{
    extract::{Path, State},
    http::StatusCode,
    routing::{get, post},
    Json, Router,
};
use serde::{Deserialize, Serialize};
use std::sync::Arc;
use tokio::sync::RwLock;

#[derive(Clone, Serialize)]
struct User {
    id: u64,
    name: String,
    email: String,
}

#[derive(Deserialize)]
struct CreateUser {
    name: String,
    email: String,
}

type AppState = Arc<RwLock<Vec<User>>>;

async fn list_users(State(state): State<AppState>) -> Json<Vec<User>> {
    let users = state.read().await;
    Json(users.clone())
}

async fn create_user(
    State(state): State<AppState>,
    Json(input): Json<CreateUser>,
) -> (StatusCode, Json<User>) {
    let mut users = state.write().await;
    let user = User {
        id: users.len() as u64 + 1,
        name: input.name,
        email: input.email,
    };
    users.push(user.clone());
    (StatusCode::CREATED, Json(user))
}

async fn get_user(
    State(state): State<AppState>,
    Path(id): Path<u64>,
) -> Result<Json<User>, StatusCode> {
    let users = state.read().await;
    users
        .iter()
        .find(|u| u.id == id)
        .cloned()
        .map(Json)
        .ok_or(StatusCode::NOT_FOUND)
}

#[tokio::main]
async fn main() {
    let state: AppState = Arc::new(RwLock::new(Vec::new()));

    let app = Router::new()
        .route("/users", get(list_users).post(create_user))
        .route("/users/{id}", get(get_user))
        .with_state(state);

    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

// lib.rs
use wasm_bindgen::prelude::*;

#[wasm_bindgen]
pub fn fibonacci(n: u32) -> u64 {
    match n {
        0 => 0,
        1 => 1,
        _ => {
            let mut a: u64 = 0;
            let mut b: u64 = 1;
            for _ in 2..=n {
                let temp = b;
                b = a + b;
                a = temp;
            }
            b
        }
    }
}

// JavaScript
import init, { fibonacci } from './pkg/my_wasm.js'

await init()
console.log(fibonacci(50)) // Runs at near-native speed in the browser

#![no_std]
#![no_main]

use esp_hal::prelude::*;

#[entry]
fn main() -> ! {
    let peripherals = esp_hal::init(esp_hal::Config::default());
    let mut led = peripherals.GPIO2.into_push_pull_output();

    loop {
        led.set_high();
        delay_ms(500);
        led.set_low();
        delay_ms(500);
    }
}

# Create a new project
cargo new my-service
cd my-service

# Add dependencies
cargo add axum tokio serde

# Build and run
cargo run

# Run tests
cargo test

# Check for issues without compiling
cargo check

# Format code
cargo fmt

# Lint
cargo clippy

# Build optimized release
cargo build --release

use sqlx::PgPool;

struct User {
    id: i64,
    name: String,
    email: String,
}

async fn get_user(pool: &PgPool, id: i64) -> Result<User, sqlx::Error> {
    // This SQL is verified against your actual database at compile time
    // Typo in column name? Won't compile.
    sqlx::query_as!(
        User,
        "SELECT id, name, email FROM users WHERE id = $1",
        id
    )
    .fetch_one(pool)
    .await
}

// This won't compile — and you won't understand why at first
fn longest(x: &str, y: &str) -> &str {
    if x.len() > y.len() { x } else { y }
}

// You need lifetime annotations
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

Small project:  5-15 seconds
Medium project: 30-90 seconds
Large project:  3-10 minutes (clean build)

// Go: simple
go func() {
    result := doWork()
}()

// Rust: more ceremony
tokio::spawn(async move {
    let result = do_work().await;
});

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Week 1-2: The Rust Book (official, free)
  → Ownership, borrowing, structs, enums, pattern matching

Week 3-4: Rustlings (exercises)
  → Practice the concepts from the book

Week 5-6: Build a CLI tool
  → Use clap, serde, and file I/O

Week 7-8: Build a web service
  → Use axum, tokio, sqlx

Week 9+: Contribute to an open-source Rust project
  → ripgrep, bat, or a project you use

# Format code
rustup component add rustfmt

# Linter
rustup component add clippy

# Language server for IDE
rustup component add rust-analyzer

# Fast linker (Linux)
sudo apt install mold

# Compilation cache
cargo install sccache