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:

[1 2 3]
[999 2 3]
[999 2 3]

Data is shared. The GC tracks references and cleans up when no longer needed.

Rust’s Approach: Ownership Rules

Rust has three fundamental ownership rules:

  1. Each value has one owner
  2. When the owner goes out of scope, the value is dropped
  3. Values can be borrowed (temporarily) but not owned by multiple places

Rust:

fn main() {
    let data = vec![1, 2, 3];

    print_data(&data);     // Borrow (immutable)
    modify_data(&mut data); // ERROR! data is not mutable
    print_data(&data);
}

fn print_data(d: &Vec<i32>) {
    println!("{:?}", d);
}

fn modify_data(d: &mut Vec<i32>) {
    d[0] = 999;
}

Must make data mutable:

fn main() {
    let mut data = vec![1, 2, 3];  // Now mutable

    print_data(&data);
    modify_data(&mut data);
    print_data(&data);

    println!("{:?}", data);
}

Move Semantics

Go: Copy Semantics (Usually)

Go:

func takeOwnership(s string) {
    fmt.Println(s)
}

func main() {
    text := "Hello"
    takeOwnership(text)
    fmt.Println(text)  // Still works!
}

Output:

Hello
Hello

Strings in Go are immutable and cheap to copy (just a pointer and length).

With slices:

func takeOwnership(s []int) {
    s[0] = 999  // Modifies original!
}

func main() {
    nums := []int{1, 2, 3}
    takeOwnership(nums)
    fmt.Println(nums)  // [999 2 3]
}

Slices are references under the hood, so modifications affect the original.

Rust: Move Semantics (By Default)

Rust:

fn take_ownership(s: String) {
    println!("{}", s);
}  // s is dropped here

fn main() {
    let text = String::from("Hello");
    take_ownership(text);  // text is MOVED
    println!("{}", text);  // ERROR! text was moved
}

Error:

error[E0382]: borrow of moved value: `text`
  --> src/main.rs:8:20
   |
6  |     let text = String::from("Hello");
   |         ---- move occurs because `text` has type `String`
7  |     take_ownership(text);
   |                    ---- value moved here
8  |     println!("{}", text);
   |                    ^^^^ value borrowed here after move

Solutions:

1. Clone (explicit copy):

fn main() {
    let text = String::from("Hello");
    take_ownership(text.clone());  // Clone before moving
    println!("{}", text);  // Works!
}

2. Borrow instead of move:

fn borrow_string(s: &String) {
    println!("{}", s);
}  // Borrow ends here

fn main() {
    let text = String::from("Hello");
    borrow_string(&text);  // Borrow, don't move
    println!("{}", text);  // Works!
}

Borrowing: Immutable References

Go:

func read1(s *string) {
    fmt.Println(*s)
}

func read2(s *string) {
    fmt.Println(*s)
}

func main() {
    text := "Hello"
    read1(&text)
    read2(&text)  // Multiple references OK
}

Rust:

fn read1(s: &String) {
    println!("{}", s);
}

fn read2(s: &String) {
    println!("{}", s);
}

fn main() {
    let text = String::from("Hello");
    read1(&text);
    read2(&text);  // Multiple immutable borrows OK
}

Rule: You can have unlimited immutable borrows (&T) simultaneously.

Mutable Borrowing: One at a Time

Go:

func modify1(nums *[]int) {
    (*nums)[0] = 1
}

func modify2(nums *[]int) {
    (*nums)[0] = 2
}

func main() {
    nums := []int{0, 0, 0}
    ptr1 := &nums
    ptr2 := &nums  // Multiple mutable refs OK

    modify1(ptr1)
    modify2(ptr2)
    fmt.Println(nums)  // [2 0 0]
}

Works fine. But can lead to data races with goroutines.

Rust:

fn modify1(nums: &mut Vec<i32>) {
    nums[0] = 1;
}

fn modify2(nums: &mut Vec<i32>) {
    nums[0] = 2;
}

fn main() {
    let mut nums = vec![0, 0, 0];
    let r1 = &mut nums;
    let r2 = &mut nums;  // ERROR! Only one mutable borrow allowed

    modify1(r1);
    modify2(r2);
}

Error:

error[E0499]: cannot borrow `nums` as mutable more than once at a time

Rule: You can have only ONE mutable borrow (&mut T) at a time.

Correct version:

fn main() {
    let mut nums = vec![0, 0, 0];

    modify1(&mut nums);  // Borrow ends after this line
    modify2(&mut nums);  // New borrow starts here

    println!("{:?}", nums);  // [2 0 0]
}

No Simultaneous Read/Write

Go (compiles, but dangerous):

func main() {
    data := []int{1, 2, 3}
    reader := &data
    writer := &data

    // Simultaneous read and write (data race!)
    go func() {
        for {
            fmt.Println((*reader)[0])
        }
    }()

    go func() {
        for {
            (*writer)[0] = 999
        }
    }()

    time.Sleep(time.Second)
}

Compiles. Results in data race at runtime.

Rust (won’t compile):

fn main() {
    let mut data = vec![1, 2, 3];
    let reader = &data;      // Immutable borrow
    let writer = &mut data;  // ERROR! Can't have both

    println!("{}", reader[0]);
    writer[0] = 999;
}

Error:

error[E0502]: cannot borrow `data` as mutable because it is also borrowed as immutable

Rule: You can have EITHER:

  • Many immutable references (&T), OR
  • One mutable reference (&mut T)

But not both simultaneously.

Scope and Lifetimes

Go:

func dangling() *int {
    x := 42
    return &x  // OK! GC keeps x alive
}

func main() {
    ptr := dangling()
    fmt.Println(*ptr)  // 42
}

GC ensures x outlives the pointer.

Rust:

fn dangling() -> &i32 {
    let x = 42;
    &x  // ERROR! x is dropped at end of function
}

Error:

error[E0106]: missing lifetime specifier

Rust prevents dangling references at compile time.

Correct version:

fn not_dangling() -> i32 {
    42  // Return value, not reference
}

fn main() {
    let val = not_dangling();
    println!("{}", val);
}

Real-World Example: Building a Cache

Go: Simple but Requires Sync

Go:

package main

import (
    "fmt"
    "sync"
)

type Cache struct {
    mu   sync.RWMutex
    data map[string]string
}

func NewCache() *Cache {
    return &Cache{
        data: make(map[string]string),
    }
}

func (c *Cache) Get(key string) (string, bool) {
    c.mu.RLock()
    defer c.mu.RUnlock()
    val, ok := c.data[key]
    return val, ok
}

func (c *Cache) Set(key, value string) {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.data[key] = value
}

func main() {
    cache := NewCache()
    cache.Set("name", "Gopher")
    val, _ := cache.Get("name")
    fmt.Println(val)
}

Manual locking required. Easy to forget.

Rust: Safety Built-In

Rust:

use std::collections::HashMap;
use std::sync::{Arc, RwLock};

struct Cache {
    data: RwLock<HashMap<String, String>>,
}

impl Cache {
    fn new() -> Self {
        Cache {
            data: RwLock::new(HashMap::new()),
        }
    }

    fn get(&self, key: &str) -> Option<String> {
        let data = self.data.read().unwrap();
        data.get(key).cloned()
    }

    fn set(&self, key: String, value: String) {
        let mut data = self.data.write().unwrap();
        data.insert(key, value);
    }
}

fn main() {
    let cache = Arc::new(Cache::new());
    cache.set("name".to_string(), "Rustacean".to_string());

    if let Some(val) = cache.get("name") {
        println!("{}", val);
    }
}

RwLock ensures read/write safety. Type system prevents races.

Common Patterns

Pattern 1: Temporary Mutable Borrow

Rust:

fn main() {
    let mut data = vec![1, 2, 3];

    {
        let temp = &mut data;  // Mutable borrow
        temp.push(4);
    }  // Borrow ends here

    println!("{:?}", data);  // Usable again
}

Pattern 2: Split Borrows

Rust:

fn main() {
    let mut data = vec![1, 2, 3, 4];

    // Can't borrow data twice mutably
    // But can split it:
    let (left, right) = data.split_at_mut(2);

    left[0] = 10;
    right[0] = 20;

    println!("{:?}", data);  // [10 2 20 4]
}

Pattern 3: Entry API (Avoiding Double Lookup)

Go:

if _, ok := cache[key]; !ok {
    cache[key] = expensive_computation()
}
return cache[key]

Two lookups!

Rust:

cache.entry(key).or_insert_with(|| expensive_computation());

One lookup, borrowing rules ensure safety.

The Mental Shift

Coming from Go:

  • Think: “Who owns this data?”
  • Ask: “Do I need to modify it?”
  • Plan: “How long does this reference need to live?”

In Go, you think:

  • “Pass this data”
  • “GC will handle cleanup”

In Rust, you think:

  • “Should I move, borrow, or clone?”
  • “Is this reference still valid?”
  • “Can this be borrowed immutably?”

Conclusion

Go’s memory model:

  • Simple: pass data around freely
  • Garbage collector handles cleanup
  • Runtime overhead for GC pauses
  • Potential for data races

Rust’s ownership model:

  • Complex: must track ownership and lifetimes
  • Compile-time memory management
  • Zero runtime overhead
  • Data races impossible (in safe Rust)

Trade-off:

  • Go: Easier to write, potential runtime issues
  • Rust: Harder to write, guaranteed safety

Next: How Rust achieves this without a garbage collector.

Go to Rust Series: ← The Rust Compiler | Series Overview | No Garbage Collector →

Ownership verdict: Hardest Rust concept for Go developers. But once it clicks, you understand why Rust is so fast and safe.