121. Why Rust? Hello, cargo

Two garbage collectors deep

Think back to chapter 58. Your Drip VM is a TypeScript program, so it runs on V8, and V8 has a garbage collector^[3]. Yet you still had to write a second collector, a mark and sweep over the VM’s own object list, because only the VM knows which Drip objects are still reachable. Two collectors, stacked.

Then think back to chapter 22. Every JavaScript object carries a hidden header, and V8 decides how numbers are stored. Viscosity, the compiler you finished in Part VIII, exists because JavaScript gives you no direct say over memory layout. It has to trick the engine into a struct of arrays, using typed arrays.

Track B starts again in a language where neither trick is needed.

What Rust is, and what it costs

Rust compiles ahead of time to machine code, has no garbage collector, and still refuses to compile programs that would read freed memory (outside code marked unsafe, chapter 141)^[1]. It manages that with a set of ownership rules, checked by the compiler. They are the heart of this part of the book, and they begin in chapter 124.

Here is the same idea on the two roads. Step through it and watch when each one does its work:

V8 does a lot while your program runs: it parses, interprets bytecode with Ignition, and compiles hot code^[2]. A Rust program did all its compiling before it started.

The costs are real, and you should hear them now. The compiler rejects programs that TypeScript would happily run, and at first it will feel like arguing with it. You wait for a full compile before every run. And some designs that are trivial with a GC, such as many objects all pointing at each other, take more thought.

The same VM, measured

Is it worth it? The book’s companion code has an answer for one program you know well. In Part X you’ll port the Drip VM to Rust, as Crafting Interpreters moves from Java to C^[4]. The port, drip-rs, prints exactly what the TypeScript VM prints, byte for byte. Here it is on the benchmark programs from chapter 44:

Read it with chapter 24’s care:

• Both ran on the same shared cloud VM, on the same day. drip-rs is a release build, best of three runs. The TypeScript numbers are the one run per program that chapter 44 used. This is a first look.
• This is one port, not “Rust versus JavaScript”. Different code, or a JIT that suits a program better, could change every bar.
• string_equality fails on both. It has more constants than one chunk allows, the same 256 limit in both VMs.
• zoo_batch runs for a fixed ten seconds. The results file adds a hand count: drip-rs finished 3060 batches, the TypeScript VM 844.

Hello, Rust

Here is a complete Rust program:

fn main() {
    println!("Hello, Drip!");
}

fn main() is where every Rust program starts. There is no top-level code as in a JavaScript file. println! plays the part of console.log. The ! marks it as a macro: code that writes code at compile time. Forget the ! and the compiler tells you so. This is the real output of rustc 1.97:

error[E0423]: expected function, found
  macro `println`
 --> e1.rs:2:5
  |
2 |     println("Hello, Drip!");
  |     ^^^^^^^ not a function
  |
help: use `!` to invoke the macro

Rust’s error messages are long and specific. Read them to the end: the help: line often holds the fix. Inside the string, {} marks a gap that println! fills with the next argument. Try it:

fn main() {
    println!("Hello, Drip!");
    let n = 35;
    println!("fib({}) is slow", n);
    let sum = 2 + 3;
    println!("2 + 3 = {}", sum);
}

cargo: Rust’s npm

You can compile one file with rustc main.rs. Nobody does, past day one. Real projects use cargo, which plays the parts of npm, tsc and your test runner at once^[1].

$ cargo new hello
$ cd hello
$ cargo run
   Compiling hello v0.1.0
    Finished `dev` profile
     Running `target/debug/hello`
Hello, world!

(Output from cargo 1.97, trimmed.) cargo new made two files:

hello/
├── Cargo.toml
└── src/
    └── main.rs

Cargo.toml is the package.json: a name, a version, an edition, and a [dependencies] list. Packages come from crates.io, as npm packages come from the npm registry.

[package]
name = "hello"
version = "0.1.0"
edition = "2024"

[dependencies]

The edition picks a version of the language’s rules. New cargo projects get 2024. This book’s runnable examples use 2021, and nothing in the next chapters differs between the two.

The everyday commands:

• cargo check type-checks without making a binary. It’s the fast one, like tsc --noEmit.
• cargo build compiles to target/debug/hello. cargo run builds, then runs.
• cargo build --release turns on the optimizer and writes to target/release/. Debug builds are for working, release builds for measuring: drip-rs’s numbers above are release numbers.

drip-rs is a nice example. Its Cargo.toml declares a library crate, drip, holding the scanner, compiler, VM and collector, and a binary crate, drip-rs, a short main that reads a file and calls the library.

Your turn

Rust exercises run on the official Rust Playground, so they take a few seconds. The tests are #[test] functions; you’ll write your own in chapter 136. For now, read the starter: it looks a lot like TypeScript. i64 is a 64-bit whole number, and -> i64 means “returns one”. todo!() is a macro that crashes with “not yet implemented”, a handy placeholder.

function secondsIn(hours: number): number {
  return hours * 60 * 60;
}

fn seconds_in(hours: i64) -> i64 {
    todo!()
}

What you learned

• Rust compiles to machine code ahead of time, with no garbage collector and no JIT. The compiler checks memory safety before the program runs. The price is a stricter compiler and slower builds.
• In this book’s run, the Rust port of the Drip VM was several times faster than the TypeScript VM. One run, one port, one machine.
• fn main() is the entry point. println! is a macro.
• cargo creates, checks, builds, runs and tests projects. --release turns on optimization.
• A crate is one compilation unit: a binary (with main) or a library.

Next, variables: Rust’s let is TypeScript’s const, and number splits into a dozen types.