Rust For Javascript Developers: Why It Is Worth the Learning Curve

// Ownership rule: every value has exactly ONE owner
// When the owner goes out of scope, the value is dropped (freed)

// Python/JS: garbage collector tracks references
// x = [1, 2, 3]
// y = x // Both reference same list, GC counts references

// Rust: one owner at a time
let x = vec![1, 2, 3]; // x owns the vector
let y = x; // MOVE: x no longer owns it, y does
// println!("{:?}", x); // Compile error! x was moved
println!("{:?}", y); // Fine: y is now the owner

// Borrowing: let someone use a value without taking ownership
let x = vec![1, 2, 3];
let y = &x; // BORROW: y borrows x immutably
println!("{:?}", x); // Fine: x still owns it
println!("{:?}", y); // Fine: y is just a reference
// Both x and y can be used — neither owns, x does

// Why this matters:
// The compiler GUARANTEES no use-after-free, no dangling pointers
// At compile time, zero runtime cost, no GC pauses

// Performance comparison (same algorithm, different languages):
// JSON parsing 100MB file:
// Python: 3.2 seconds
// Node.js: 0.8 seconds
// Rust: 0.04 seconds (80x faster than Python)

// Memory for web server under load:
// Node.js: ~150MB (V8 heap)
// Rust: ~15MB (no GC overhead)

// When to choose Rust:
// 1. CLI tools that need to be fast (ripgrep is 5x faster than grep)
// 2. WebAssembly modules (runs Rust in browser at near-native speed)
// 3. High-throughput services (Actix/Axum benchmarks beat all other frameworks)
// 4. Embedded/systems programming (no OS, no GC allowed)
// 5. Replacing Python C extensions (write safe, fast Rust with PyO3)
// 6. Memory-constrained environments (Lambda/container with tight limits)

// When NOT to choose Rust:
// 1. Prototyping — iteration speed matters more than performance
// 2. Simple scripts — Python/Bash is fine
// 3. Team unfamiliar with it — learning curve is real
// 4. Heavy async I/O web apps — Node.js/Go are simpler and nearly as fast

// Axum — the most popular Rust web framework (by Tokio team)
// Cargo.toml: axum = "0.7", tokio = { version = "1", features = ["full"] }

use axum::{
 routing::{get, post},
 Router, Json, extract::Path,
 http::StatusCode,
};
use serde::{Deserialize, Serialize};

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

// Handler — feels like Express/Fastify
async fn get_user(Path(id): Path) -> Result, StatusCode> {
 // Database call would go here
 Ok(Json(User { id, name: "Alice".into(), email: "alice@example.com".into() }))
}

async fn create_user(Json(payload): Json) -> (StatusCode, Json) {
 (StatusCode::CREATED, Json(payload))
}

#[tokio::main]
async fn main() {
 let app = Router::new()
 .route("/users/:id", get(get_user))
 .route("/users", post(create_user));

 let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
 axum::serve(listener, app).await.unwrap();
}
// Benchmark: Axum handles ~500K req/sec on 8 cores
// vs Node.js Express: ~50K req/sec (10x slower)

// Compile Rust to WASM and call from JavaScript
// Cargo.toml: wasm-bindgen = "0.2"

use wasm_bindgen::prelude::*;

#[wasm_bindgen]
pub fn fibonacci(n: u32) -> u32 {
 if n < 2 { return n; }
 let mut a = 0u32;
 let mut b = 1u32;
 for _ in 2..=n {
 let c = a + b;
 a = b;
 b = c;
 }
 b
}

// Build: wasm-pack build --target web

// In JavaScript:
import init, { fibonacci } from './pkg/my_wasm';
await init();
console.log(fibonacci(40)); // Runs Rust code in browser
// 100x faster than equivalent JavaScript for numeric computation

// Real use cases:
// - Image/video processing in browser (Figma uses WASM)
// - Cryptography (run Rust crypto in browser, no JS crypto bugs)
// - Game logic (high-performance game loops)
// - Parse/transform large datasets client-side

// Write performance-critical Python extensions in Rust
// Python: pandas/numpy are C extensions — PyO3 lets you do the same

use pyo3::prelude::*;

#[pyfunction]
fn sum_large_array(arr: Vec) -> f64 {
 arr.iter().sum()
}

#[pymodule]
fn my_rust_ext(_py: Python, m: &PyModule) -> PyResult<()> {
 m.add_function(wrap_pyfunction!(sum_large_array, m)?)?;
 Ok(())
}

// Build: maturin develop
// In Python:
import my_rust_ext
result = my_rust_ext.sum_large_array([1.0, 2.0, 3.0, ...])
// 10-50x faster than pure Python, same API as any Python function

// Real example: polars data library is Rust under the hood
// Result: 10-50x faster than pandas for large datasets