Rust — Beginner to Advanced (from TypeScript & Python)

Overview

This cluster is Rust for people who already ship TypeScript and Python. The core model is ownership at compile time, not a garbage collector.

Verified on 2026-10-01: stable rustc 1.98.1 (the 1.98.1 point release of 2026-09-03), edition 2024. Sources are the stable release notes and the stable channel manifest. 1.99.0 was still beta at that write. Update 2026-10-05: 1.99.0 shipped as stable on 2026-10-01; the samples need no changes for it.

The JS/TS language hub and the Python language hub are the parallel intuition for a host loop and a GIL. They are not a substitute for moves, Result, or Send.

Comparative map

Who owns the value

flowchart TB
  A["Step 1 let s = String::from - s owns the heap buffer Ready"]
  B["Step 2 How is s used next Ready"]
  M["Step 3a Move - t owns it, s is unusable Ready"]
  R["Step 3b Shared borrow - many readers Ready"]
  W["Step 3c Exclusive borrow - one writer Ready"]
  E["Step 4 Borrow ends at its last use Ready"]
  D["Step 5 Owner leaves scope - Drop frees memory once Ready"]
  F["Failure path - compile error E0382 Ready"]
  A -->|continues| B
  B -->|let t = s| M
  B -->|pass &s| R
  B -->|pass &mut s| W
  R -->|continues| E
  W -->|continues| E
  M -->|continues| D
  E -->|continues| D
  M -->|use s after the move| F

Press Run. Snippets must be self-contained — no network, files, or native modules.

Rosetta — move versus alias

Rust moves a non-Copy String. The source is gone.

fn takes(s: String) {
    println!("owned {s}");
}

fn main() {
    let s = String::from("hello");
    takes(s);
    // println!("{s}"); // used after move
}

TypeScript aliases the same object. The garbage collector decides later.

function takes(s: { text: string }) {
  console.log("owned", s.text);
}
const s = { text: "hello" };
takes(s);
console.log(s.text);

Python binds another name to the same object.

def takes(s: str) -> None:
    print("owned", s)

s = "hello"
takes(s)
print(s)

To keep using the data in Rust, pass a shared borrow or clone on purpose.

Rosetta — Result versus throw

fn parse_port(s: &str) -> Result<u16, std::num::ParseIntError> {
    s.parse()
}

fn main() {
    match parse_port("8080") {
        Ok(p) => println!("port {p}"),
        Err(e) => eprintln!("bad: {e}"),
    }
}

function parsePort(s: string): number {
  const n = Number.parseInt(s, 10);
  if (Number.isNaN(n)) throw new Error(`bad: ${s}`);
  return n;
}

def parse_port(s: str) -> int:
    return int(s)

Rust puts failure in the type. TypeScript and Python unwind with an exception the signature does not have to name.

Rosetta — a small concurrent sketch

use std::thread;

fn main() {
    let handle = thread::spawn(|| 21 * 2);
    println!("{}", handle.join().unwrap());
}

async function main() {
  const v = await Promise.resolve(21 * 2);
  console.log(v);
}
main();

import asyncio

async def main() -> None:
    v = await asyncio.sleep(0, result=21 * 2)
    print(v)

asyncio.run(main())

A Rust thread is an OS thread (true parallelism; the closure must be Send + 'static, or use thread::scope). A JavaScript Promise stays on the host loop. Python asyncio is cooperative on one thread unless you add processes. Rust async still needs an explicit runtime.

What the rest of the cluster adds

1. Toolchain covers rustup, Cargo, and edition 2024.
2. Ownership covers moves, borrows, and lifetimes.
3. Types covers structs, enums, and match.
4. Traits covers generics and dyn Trait.
5. Errors covers Result, Option, and propagation.
6. Collections, pointers, concurrency, unsafe, and tests close the ring.

Interview Q&A

Pitfalls

• Cloning every value so the checker stays quiet.
• Storing references in structs before you can move and borrow.
• unwrap in library code.
• Blocking a Tokio worker with sync I/O.
• Treating unsafe as a style escape.

Go Deeper

• The Rust Programming Language
• Rust By Example
• The Rust Edition Guide
• Rust stable release notes
• Jon Gjengset — Crust of Rust
• Rust YouTube channel