Rust of Go: twee talen, twee soorten pijn

Dit artikel is voor ontwikkelaars die een taal moeten kiezen voor servers, netwerkdiensten of container-tooling, en die willen weten wat ze opgeven als ze voor de een of de ander gaan. We bouwen een werkend project in Rust op met Cargo, en zetten dat naast wat Go doet — inclusief de dingen die het bronmateriaal niet uitlegt maar die je wél tegenkomt.

Vereisten

• Linux of macOS (Windows werkt via WSL2)
• `rustup` 1.27 of nieuwer voor de Rust-installatie
• Go 1.19 of nieuwer als je de vergelijking zelf wilt natrekken
• Een internetverbinding — `rustup` haalt de nieuwste stabiele compiler op

Je hebt geen IDE nodig. Een editor en een terminal zijn genoeg. De Rust-compiler is streng genoeg dat je hem als tweede reviewer kunt inzetten.

Stappen

1. Installeer Rust via rustup

`rustup` beheert niet alleen de compiler maar ook de toolchain-versies. Dat lijkt overhead tot je een project tegenkomt dat op een oudere versie moet blijven.

```bash curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh ```

Kies optie 1 voor de standaardinstallatie. Daarna:

```bash source "$HOME/.cargo/env" rustc --version ```

Je krijgt iets als `rustc 1.75.0`. De Rust 1.x-compatibiliteitsbelofte betekent dat code die nu compileert, dat ook blijft doen onder toekomstige 1.x-versies. Voor bedrijven met software die jaren meegaat is dat geen detail.

2. Maak een project aan met Cargo

Cargo is build-systeem én package manager. De meeste Rust-gebruikers — Rustaceans, als je de terminologie wilt — doen alles via Cargo. Het compileert je code, haalt dependencies op en bouwt die dependencies ook.

```bash cargo new guessing_game cd guessing_game ```

Dit maakt een `Cargo.toml` en een `src/main.rs` met een Hello World erin. Voor een simpel programma heb je geen externe dependencies nodig. Zodra je project groeit, wordt Cargo het verschil tussen overzicht en een map vol zelfgeschreven Makefiles.

3. Voeg een externe crate toe

Voor de guessing game hebben we random getallen nodig. Die zitten niet in de standard library.

```bash cargo add rand ```

Dit schrijft de dependency in `Cargo.toml` en pakt de nieuwste versie. Cargo downloadt de crate en zijn transitive dependencies, en bouwt alles mee. De eerste build duurt daardoor langer dan je gewend bent van een taal zonder package manager. Reken op een minuut of wat bij een koude cache.

4. Schrijf de guessing game

Vervang `src/main.rs` door:

```rust use rand::Rng; use std::cmp::Ordering; use std::io;

fn main() { println!("Raad het getal tussen 1 en 100.");

let secret_number = rand::thread_rng().gen_range(1..=100);

loop { println!("Voer je gok in.");

let mut guess = String::new();

io::stdin() .read_line(&mut guess) .expect("Kon niet lezen");

let guess: u32 = match guess.trim().parse() { Ok(num) => num, Err(_) => continue, };

println!("Je gokte: {}", guess);

match guess.cmp(&secret_number) { Ordering::Less => println!("too low"), Ordering::Greater => println!("too high"), Ordering::Equal => { println!("you win"); break; } } } } ```

Twee dingen vallen op. `let mut guess` — Rust maakt variabelen standaard immutable, je moet `mut` expliciet zetten. En de `match` op `parse()` dwingt je de foutcase af te handelen. Er is geen weg om te doen alsof het goed ging.

5. Begrijp wat match doet

`match` vergelijkt een waarde met een reeks patronen en voert de code uit bij het eerste dat past. Het bronmateriaal vergelijkt het met een muntsoorteermachine: munten gaan erin, worden op grootte naar het juiste kanaal gestuurd.

Het verschil met een `switch` in C of een reeks `if`-statements zit in de compiler. Die controleert of je álle mogelijke gevallen hebt afgedekt. Mis je er een, dan compileert het niet. Dat is waarom de `Err(_) => continue` in stap 4 verplicht is en niet optioneel.

6. Compileer en draai

```bash cargo run ```

Cargo compileert en start het binary. Bij de eerste run bouwt het ook `rand` en diens dependencies. Daarna is het incrementeel en snel.

Voor een release-build met optimalisaties:

```bash cargo build --release ```

Het binary staat dan in `target/release/guessing_game`. De debug-build in `target/debug/` is groter en trager, maar bevat symbolen voor debugging.

7. Bekijk de modulestructuur

Rust organiseert code in een moduleboom. Je benadert items via paden, en er zijn twee soorten.

Een absoluut pad begint bij de crate root. Voor code uit een externe crate begint het met de naam van die crate (`rand::Rng`). Voor code uit je eigen crate begint het met het trefwoord `crate`.

Een relatief pad begint bij de huidige module en gebruikt `self`, `super` of een identifier. Dit klinkt als bureaucratie tot je project honderd bestanden telt. Dan is het het verschil tussen kunnen navigeren en gokken.

8. Zet het naast Go

Go koos een andere route. De taal ontstond in 2007 uit frustratie over de complexiteit van C++ en Java bij grote projecten — een tijd waarin GitHub nog niet bestond en de meeste machines één processor hadden.

Waar Rust je dwingt tot nadenken over ownership en geheugen, geeft Go je een garbage collector en een minimale syntaxis. Goroutines en channels maken concurrency laagdrempelig. De prijs: je krijgt geen compile-time garanties over dataraces, en een nil-pointer blijft een runtime-verrassing.

Go 1.19, vijf maanden na 1.18, bracht vooral toolchain- en runtime-wijzigingen. Eén kleine taalwijziging, een correctie in het bereik van typeparameters in methode-declaraties. Bestaande programma's merken er niets van, want Go houdt vast aan de Go 1-compatibiliteitsbelofte.

Verificatie

Controleer of je Rust-installatie compleet is:

```bash rustc --version && cargo --version && rustup show ```

Je ziet de compiler, Cargo en de actieve toolchain. Draai daarna je project:

```bash cargo run ```

Voer een gok in. Krijg je `too high`, `too low` of `you win`, dan werkt de hele keten: compiler, Cargo, de `rand`-crate en je match-logica.

Voor een schonere check zonder interactie:

```bash cargo build --release && ./target/release/guessing_game ```

Veelgestelde problemen

`cargo: command not found` na installatie. De PATH is niet bijgewerkt in je huidige shell. `source "$HOME/.cargo/env"` lost het op voor deze sessie; voor permanent moet die regel in je `.bashrc` of `.zshrc`.

Build duurt lang bij de eerste run. Dat is Cargo die dependencies ophaalt en compileert. Volgende builds zijn incrementeel. Wil je dit vermijden, beperk dan het aantal crates — elke dependency is ook een stuk code dat je niet zelf hebt geschreven en dat meecompileert.

`cannot borrow as mutable` of een lifetime-fout. Dit is de compiler die je ergens op wijst waar je in Go pas in productie achter was gekomen. Lees de foutmelding volledig; `rustc` geeft vaak de exacte regel en een voorstel. Het is even wennen en daarna lastig om terug te gaan.

Tot slot

Rust geeft je controle over geheugen zonder garbage collector, en een compiler die weigert half werk te accepteren. Go geeft je een taal die je in een middag leert en die compileert voordat je koffie hebt gezet. Voor system-level software waar een crash duur is, weegt het Rust-argument zwaar. Voor microservices en CLI-tools waar ontwikkelsnelheid telt, is Go vaak de pragmatische keuze — Docker en Kubernetes zijn niet voor niets in Go geschreven.

De vraag is niet welke taal beter is. De vraag is welke fouten je kunt veroorloven.