# Rust

## Hvad det er

Rust er et programmeringssprog til det arbejde, der traditionelt laves i C og C++, hvor et program selv styrer sin hukommelse og ofte linkes ind i software skrevet i andre sprog. Compileren laver maskinkode på forhånd. Version 1.0 blev annonceret den 15. maj 2015 som et sprog, der forener kontrol på lavt niveau over ydelsen med sikkerhedsgarantier, opnået uden en garbage collector eller et runtime, og det er netop det, der lader et Rust-bibliotek træde i stedet for et bibliotek i C.

Hukommelsen styres gennem ejerskab, et sæt regler, som compileren tjekker. Hver værdi har én ejer ad gangen, og når ejeren går ud af scope, droppes værdien, og dens hukommelse frigives på et tidspunkt, der ligger fast, når programmet oversættes, og ikke når en collector næste gang kigger forbi. Kode, der har brug for en værdi uden at overtage den, låner en reference, og lånereglerne tillader på ethvert tidspunkt enten én foranderlig reference eller et vilkårligt antal uforanderlige og kræver, at hver reference er gyldig. Et program, der bryder en regel, oversættes ikke. De samme regler udelukker datakapløb, så to tråde, der skriver til de samme data uden synkronisering, er en kompileringsfejl og ikke en fejl, der kun viser sig af og til.

Rust har ingen undtagelser. En funktion, der kan fejle på en forventet måde, returnerer et `Result`, der rummer enten en værdi eller en fejl, og compileren advarer som standard, hvis kalderen lader resultatet være ubrugt; en fejl, som programmet ikke kan komme sig over, som at læse forbi enden af et array, går i stedet gennem makroen `panic!`.

Statisk analyse er konservativ, så compileren afviser nogle programmer, der ville have været i orden, og noget arbejde, som at styre hardware eller kalde et andet sprog, kan slet ikke tjekkes. Til de tilfælde findes `unsafe`, der låser fem ekstra evner op, blandt dem at dereferere en rå pointer og at kalde en usikker funktion, hvilket som standard omfatter enhver funktion, der er erklæret fra C. Det slår ikke borrow checkeren fra; det markerer de linjer, hvor programmøren og ikke compileren står inde for hukommelsessikkerheden, så sikkerheden ved disse operationer afhænger af, at programmøren opretholder deres kontrakter, også i den omgivende sikre kode. Rust-bogens råd er at holde de blokke små og pakke dem ind i en sikker grænseflade, og sådan er dele af standardbiblioteket bygget.

Der kommer en ny compiler hver sjette uge. Ændringer, der ville bryde eksisterende kode, venter på en udgave, en såkaldt edition, som kommer cirka hvert tredje år. Der er fire, 2015, 2018, 2021 og 2024, og den nyeste blev stabil den 20. februar 2025 med Rust 1.85.0. Hver pakke angiver sin udgave i `Cargo.toml`, hver compiler bygger alle de udgaver, der kom før den, og pakker i forskellige udgaver linkes sammen, så et projekt rykker op, når det selv vælger. Cargo, pakkehåndteringen og buildværktøjet, følger med sproget, rustfmt holder kodestilen ensartet, og tredjepartsbiblioteker kommer som pakker, der kaldes crates.

## Hvorfor det betyder noget

I C og C++ bliver en pointer, der bruges, efter at dens hukommelse er frigivet, eller to tråde, der skriver de samme data, oversat uden indvendinger og fejler senere, af og til og ofte langt fra årsagen. Rust gør de programmer til kompileringsfejl, og fordi tjekkene kører, når programmet bygges, betaler det færdige program intet for dem.

Uden en garbage collector og uden et runtime at slæbe rundt på kan Rust-kode ligge under software i andre sprog. Alt, der kan kalde C, kan kalde en Rust-kerne gennem en C-grænseflade, så én gennemtestet implementering kan betjene klienter på flere platforme. Rust-bogen nævner kommandolinjeværktøjer, webtjenester, indlejrede enheder og store dele af webbrowseren Firefox blandt sprogets anvendelser i produktion.

Prisen betales på forhånd. Koden skal formes, så compileren kan se, at den er sikker, og det betyder ofte at beslutte, hvem der ejer en værdi, i stedet for at sende referencer frit rundt, og bogen siger selv, at ejerskab tager tid at vænne sig til. Når compileren afviser et program, den ikke kan verificere, er svaret som regel en anden struktur og ikke en vej uden om tjekket.

Stabilitet er den anden halvdel af handlen. Siden 1.0 har ændringer, der bryder eksisterende kode, stort set været udelukket, så en sådan ændring kun kommer gennem en udgave, som en pakke selv vælger.

## Sådan ser det ud i praksis

I porteføljen er Rust kernen under en native beskedklient til macOS: protokollens velafprøvede kerne er skrevet i Rust og stiller en C-grænseflade til rådighed, og klienten, 11.141 linjer Swift fordelt på 53 filer, linker den ind som et statisk arkiv, kompileret fra en fastlåst upstream-revision. Fastlåsningen betyder noget, fordi C-grænsefladen er kontrakten: en kerne i bevægelse ændrer kontrakten uden at ændre en eneste linje Swift. Alt, hvad C-grænsefladen returnerer, har en ejerskabsregel, og tager man fejl af én, får man en lækage eller et nedbrud uden nogen advarsel fra compileren imellem, så en tynd indpakning ejer hver pointer og hver streng, der krydser grænsen, og intet lag over den ser en rå pointer.

At linke den kerne ind i et program betyder at levere alt, hvad den afhænger af, og det er emnet for en licensrevision af 644 Rust-crates. Hver crate erklærer sin licens som et udtryk, og revisionen tjekker hvert udtryk i hele afhængighedsgrafen mod en tilladelsesliste ved hvert build og læser OR som et valg mellem licenser og AND som en pligt til at overholde begge. Alt, der ikke matcher, får buildet til at fejle. Fordi et tjek, der aldrig har fejlet, ser ud præcis som et, der slet ikke kan fejle, blev det bragt til at fejle to gange med vilje: én gang ved at omskrive en crates licens til et vilkår, listen afviser, og én gang ved at flytte den fastlåste kernerevision uden at generere revisionen igen. Den læser kun deklarerede metadata og er ikke juridisk rådgivning.

Dette site har ingen Rust-kildekode selv; det møder sproget på afstand gennem Ruff, der er skrevet i Rust og tjekker hvert Python-script, et commit rører ved.

## Hvor det går galt

Det meste besvær med Rust ligger i kanterne af det, compileren tjekker: aritmetik i et optimeret build, grænsen til et andet sprog og kode, der følger med en afhængighed.

Aritmetik løber rundt i et release-build. En tæller, der gik i panik med et overløb under test, bliver i produktion stille til et lille tal. I debug-builds tjekker Rust heltalsaritmetik for overløb og går i panik; et build med `--release` udelader tjekket og løber rundt, så 256 i en `u8` bliver til 0, og bogen betragter det som en fejl at stole på den omløbning. Hvor en værdi kan løbe over, så vælg opførslen udtrykkeligt: `checked_*` returnerer `None`, `saturating_*` stopper ved grænsen, og `wrapping_*` løber rundt med vilje.

```rust
fn add_stock(on_hand: u8, delivered: u8) -> Option<u8> {
    // None when the sum does not fit, in debug and release alike
    on_hand.checked_add(delivered)
}
```

Hukommelsesfejl vender tilbage ved C-grænsen. Et program, hvis Rust-side bygger uden en eneste advarsel, lækker hukommelse eller går ned inde i et fremmed kald. Funktioner, der er erklæret i en `extern`-blok, er usikre at kalde, fordi det andet sprog ikke håndhæver nogen af Rusts regler, så hvem der frigiver hver pointer, er en konvention, som compileren ikke kan se. Sæt én indpakning til at styre hver pointer og streng, der krydser grænsen, skriv hver ejerskabsregel ned ved siden af kaldet, og udstil kun en sikker grænseflade over den.

En panik når C, og processen afbrydes. En Rust-funktion, der kaldes fra C, går i panik, og i stedet for en fejlværdi stopper hele programmet. Siden Rust
1.81, der udkom den 5. september 2024, afbryder en panik, der forsøger at forlade en funktion erklæret med den almindelige `"C"`-grænseflade, processen. Gør fejl til returværdier, før de når grænsen, og erklær kun en funktion med `"C-unwind"`, hvor koden på den anden side forventer, at stakken afvikles.

En rutineopdatering ændrer licensen for hele buildet. Et versionsløft tre niveauer nede trækker en crate ind, hvis licens produktet ikke kan acceptere, og intet i buildet siger det. Hver crate erklærer sin egen licens, og forpligtelserne lægges sammen på tværs af hele grafen. Tjek hver crates udtryk mod en tilladelsesliste ved hvert build, lad alt, der ikke matcher, fejle, og bryd tjekket med vilje én gang for at bevise, at det slår til.

## Læs mere
* The Rust Programming Language — den officielle bog, fra installation over ejerskab og fejlhåndtering til usikker kode.
* What Is Ownership? — de tre ejerskabsregler, og hvordan hukommelse frigives uden en garbage collector.
* Unsafe Rust — de fem usikre evner, rå pointere og kald til C gennem `extern`.
* The Manifest Format — felterne `edition`, `rust-version` og `license` i `Cargo.toml`.
* Announcing Rust 1.0 — de oprindelige mål og det stabilitetsløfte, der begyndte med 1.0.

=> /da/portfolio/built-a-native-macos-client-in-swift-6/ en native beskedklient til macOS
=> /da/portfolio/know-the-licence-of-everything-you-ship/ en licensrevision af 644 Rust-crates
=> https://doc.rust-lang.org/book/ The Rust Programming Language
=> https://doc.rust-lang.org/book/ch04-01-what-is-ownership.html What Is Ownership?
=> https://doc.rust-lang.org/book/ch20-01-unsafe-rust.html Unsafe Rust
=> https://doc.rust-lang.org/cargo/reference/manifest.html The Manifest Format
=> https://blog.rust-lang.org/2015/05/15/Rust-1.0/ Announcing Rust 1.0

=> https://engineer.company/da/glossary/rust/ Denne side på nettet
