Yesterday we saw that let gives you an immutable binding. But sometimes you genuinely need a variable to change — a counter, a running total, a buffer being filled. For that, you use let mut. The syntax let mut count = 0; count += 1; count += 1; println!("{}", count); // 2 Adding mut tells both the compiler and the reader: this value is intentionally going to change. Why does the distinction matter? It’s a communication tool. When you see let in Rust code, you immediately know: this value won’t change. When you see let mut, you know to pay closer attention — something is being mutated here. ...

In Java, variables are mutable unless you slap final on them. Most developers don’t bother, so everything ends up mutable by default — even when it doesn’t need to be. Rust flips this. Variables are immutable by default. You have to explicitly opt into mutability. Declaring a variable let name = "Alice"; That’s it. No type annotation needed here — Rust infers &str from the value. What happens if you try to reassign? let x = 5; x = 10; // ❌ compiler error: cannot assign twice to immutable variable The compiler stops you immediately. This isn’t a runtime crash or a warning — it’s a hard error. ...

You’ve seen println!("Hello, world!") already. But why the exclamation mark? In Rust, ! means you’re calling a macro, not a regular function. Macros vs functions A regular function in Rust has a fixed number of typed parameters. A macro can accept a variable number of arguments of different types — which is exactly what you need for printing. println!("Hello"); // zero args println!("Hello, {}!", "Rust"); // one arg println!("{} + {} = {}", 1, 2, 1 + 2); // three args If println were a regular function, you’d need a different overload for each case. Instead, macros handle this at compile time. ...

Open src/main.rs and you’ll see this: fn main() { println!("Hello, world!"); } Familiar? It should be. But there are a few things worth noticing if you’re coming from Java. No class wrapper In Java, everything lives inside a class — even main: public class Main { public static void main(String[] args) { System.out.println("Hello, world!"); } } In Rust, fn main() is a free function. No class, no public static, no String[] args unless you need it. Less ceremony, more signal. ...

In Java, starting a project means choosing Maven or Gradle, creating a directory structure, writing a pom.xml or build.gradle, and eventually getting to actual code. In Rust, you run one command. Creating a project cargo new hello-rust cd hello-rust That’s your entire project setup. Here’s what Cargo creates: hello-rust/ ├── Cargo.toml ← your pom.xml / build.gradle └── src/ └── main.rs ← your entry point Clean. No boilerplate. Cargo.toml — the project descriptor [package] name = "hello-rust" version = "0.1.0" edition = "2021" [dependencies] The [dependencies] section is where you add libraries — Rust calls them crates. It’s the equivalent of your <dependencies> block in Maven. ...

Setting up a Java project used to mean downloading a JDK, setting JAVA_HOME, maybe fighting with your IDE, and picking a build tool. Rust makes this refreshingly simple. One command to rule them all curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh That’s it. This installs rustup — Rust’s toolchain manager. Think of it as the equivalent of SDKMAN for Java, except it’s the official way to install Rust and everyone uses it. ...

You’ve been writing Java for years. It works. Your apps run fine. So why would you even look at Rust? Here’s the honest answer: you probably don’t need Rust for most things. Java is excellent. But Rust solves a specific set of problems in a way no other language does — and once you see it, it’s hard to unsee. The three things Java leans on that Rust doesn’t 1. A Garbage Collector Java manages memory for you. That’s great for productivity, but it comes with a cost — GC pauses, higher memory usage, and unpredictable latency. Rust has no GC. Memory is managed at compile time, with zero runtime overhead. ...