Rust

Go to Rust Series: ← String vs &str | Series Overview The Problem: Nil and Errors Tony Hoare (inventor of null references) called it his “billion-dollar mistake.” Go’s approach: nil values and explicit error returns Rust’s approach: Option<T> for absence, Result<T, E> for errors Go: Nil Pointers Go: func findUser(id int) *User { if id == 0 { return nil } return &User{ID: id, Name: "Alice"} } func main() { user := findUser(0) if user != nil { fmt.Println(user.Name) } else { fmt.Println("User not found") } } Problem: Easy to forget nil check: ...

Go to Rust Series: ← Mut vs Immutable | Series Overview | Option and Result → The Confusion Go has one string type: var s string = "hello" Rust has two main string types: let s1: String = String::from("hello"); // Owned string let s2: &str = "hello"; // String slice Why two types? It’s one of the most confusing aspects for Go developers learning Rust. Go: One String Type Go: package main import "fmt" func main() { // All of these are just "string" s1 := "hello" s2 := "world" s3 := s1 + " " + s2 printString(s1) printString(s3) } func printString(s string) { fmt.Println(s) } Simple. Everything is string. ...

Go to Rust Series: ← Lifetimes Explained | Series Overview | String vs &str → The Default Difference Go: Everything is mutable by default Rust: Everything is immutable by default This single difference shapes how you write code in each language. Go: Mutable by Default Go: func main() { x := 10 x = 20 // No problem x = x + 5 // No problem fmt.Println(x) // 25 } Variables are mutable unless you use const (which is very limited): const PI = 3.14 // Compile-time constant only PI = 3.14159 // Error Rust: Immutable by Default Rust: ...

Go to Rust Series: ← No Garbage Collector | Series Overview | Mut vs Immutable → The Concept Go Doesn’t Need Lifetimes are Rust’s way of tracking how long references are valid-all at compile time. Go doesn’t need lifetimes because the garbage collector tracks reference validity at runtime. Rust needs them because there’s no GC. Go: References Just Work Go: func getFirst(a, b string) string { if len(a) > len(b) { return a } return b } func main() { x := "short" y := "longer" result := getFirst(x, y) fmt.Println(result) } No annotations needed. GC ensures result stays valid. ...

Go to Rust Series: ← Ownership and Borrowing | Series Overview | Lifetimes Explained → The Fundamental Trade-Off Go: Automatic memory management via garbage collection Rust: Compile-time memory management via ownership Both approaches have profound implications for performance, predictability, and developer experience. How Go’s GC Works Go: func allocateData() { for i := 0; i < 1000000; i++ { data := make([]byte, 1024) // Use data... // No explicit free needed } } Go’s GC: Tracks all allocations Periodically stops the world (STW) Scans for reachable objects Frees unreachable memory GC pause times: Typically 1-10ms, but can spike higher. ...

Go to Rust Series: ← The Rust Compiler | Series Overview | No Garbage Collector → The Core Difference Ownership is Rust’s most important concept-and the one Go completely lacks. In Go, the garbage collector handles memory. In Rust, the ownership system handles memory at compile time, with zero runtime cost. Go’s Approach: Share and GC Go: package main import "fmt" func main() { data := []int{1, 2, 3} // Pass to multiple functions printData(data) modifyData(data) printData(data) // Still usable fmt.Println(data) } func printData(d []int) { fmt.Println(d) } func modifyData(d []int) { d[0] = 999 // Modifies original } Output: ...

Go to Rust Series: ← Setting Up Rust | Series Overview | Ownership and Borrowing → The First Encounter Week 1 with Go: I shipped features. Week 1 with Rust: I fought the compiler. This isn’t a bug-it’s Rust’s design. The compiler is strict, verbose, and often frustrating. But after fighting it for weeks, I realized: it’s actually trying to help me. Compiler Philosophy Go: Trust the Developer Go’s compiler does basic checks and gets out of your way: ...

Go to Rust Series: ← Hello World Comparison | Series Overview | The Rust Compiler → Installation: First Impressions Go: Download and Done Installation: Go to golang.org/dl Download installer for your OS Run installer Done Verify: $ go version go version go1.22.0 linux/amd64 That’s it. Go is installed. One binary, one version, ready to use. Where it lives: $ which go /usr/local/go/bin/go Single installation directory. Simple. Rust: The Rustup Way Installation: $ curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh This installs rustup, Rust’s toolchain manager (like nvm for Node or rbenv for Ruby). ...

Go to Rust Series: ← Cargo vs Go Modules | Series Overview | Setting Up Rust → The “Simple” Hello World Every programming tutorial starts with “Hello, World!” It’s supposed to be trivial. But comparing Go and Rust versions reveals fundamental philosophical differences. Go’s Hello World main.go: package main import "fmt" func main() { fmt.Println("Hello, World!") } Compile and run: go run main.go Output: Hello, World! Done. Five lines. Zero surprises. Rust’s Hello World main.rs: ...

Go to Rust Series: ← Day 1 Impressions | Series Overview | Hello World Comparison → First Impression: Cargo is Actually Great After struggling with Rust’s ownership system on Day 1, I expected the tooling to be equally complex. I was wrong. Cargo is fantastic. Coming from Go modules (which are already pretty good), Cargo feels like a spiritual successor with better UX. Project Initialization Go: mkdir myproject cd myproject go mod init github.com/username/myproject Creates go.mod: ...