Rust is een vrij nieuwe programmeertaal, die nog constant in ontwikkeling is. Gelukkig met de garantie dat nieuwe versies altijd honderd procent backward compatible zijn, dus wat vandaag werkt, werkt in een volgende versie nog steeds.

Installatie van Rust

Om met Rust te werken hebben we de Rust compiler nodig en het build systeem van Rust, dat Cargo heet. Cargo doet min of meer wat make/Makefile doet in C. De installatie van Rust zelf is vrij eenvoudig en wordt hier prima beschreven.

Voor andere besturingssystemen, zoals MacOS of MS Windows, kom je met Google of ChatGPT ook makkelijk uit de voeten.

Updaten en bewerken voor luie mensen

Omdat Rust nog in ontwikkeling is en met grote regelmaat updates krijgt, is het handig om die updates ook regelmatig te downloaden. Natuurlijk met een minimum aan moeite, dus dat doen we met een Bash-script, rust_update.sh:

#!/bin/bash
cd ~/.cargo
rustup update stable

met chmod +x rust_update.sh maak je dit uitvoerbaar. Voer het eerst even uit om te testen. Als het goed is krijg je bericht dat een update is geplaatst, of dat er geen update beschikbaar was. Vervolgens wil je dit script bijvoorbeeld wekelijks uitvoeren. Dat kan je doen door er een zogenaamde  cronjob van te maken, dus een job op een vaste tijd. Dat doe je met het commando crontab -e

Je komt nu in een file waar alle cronjobs staan. Voeg hier de volgende regel toe:

0 0 * * 0 /home/pi/rust_update.sh

en sla het gewijzigde bestand op. Let op, /home/pi is mijn home-directory, als je een andere gebruikt, vul je natuurlijk een andere in. Vanaf nu zal je computer iedere week een update trachten uit te voeren.

Zoals ik een writec-script heb gemaakt voor C, heb ik ook een writers gemaakt, met bijbehorende template.rs file. Deze kan je op GitHub vinden, samen met het update-scriptje van hiervoor. Plaats de bestanden in de correcte directories, geef ze met chmod een -x mee, en alles zou moeten werken.

Een eerste programma

Het is een gezonde gewoonte om Rust te benaderen via Cargo, de build-manager. We gaan dus niet zoals in C beginnen met een programma dat we programma.c noemen, maar we beginnen met een nieuw project met

cargo new programma
cd programma/src
rm main.rs
writers main.rs

Met cargo hebben we een project aangemaakt, in een eigen directory, dat de naam heeft die we aan het programma hebben gegeven, in dit geval programma. Cargo maakt dan meteen een subdirectory aan met de naam /src, en plaatst daarin een file main.rs, een eigen template. Omdat we daar zelf al voor zorgen kan die gewist worden. Met writers maken we onze eigen main.rs op basis van onze eigen template. Op GitHub heb ik een voorbeeld van een simpel eerste programma gezet.

Waar we in de code altijd een functie main() hebben, net als in C, hebben we dankzij cargo dus ook altijd main.rs als naam voor de sourcecode voor het hoofdprogramma. Als we in /programma het commando cargo run geven zal de source uit /src gecompileerd worden, en met de projectmanager als programma-naam in /target worden geplaatst, en direct worden uitgevoerd.

Mocht je ooit een serieus programma schrijven dat je wil gebruiken of zelfs aan andere wil uitdelen, dan heb je nog opties om een release-build te maken met cargo. En ook voor debugging zijn er opties. Maar voorlopig is de run optie vooral bruikbaar voor wie met Rust wil klooien. Het werkt immers vrijwel hetzelfde als in C, maar allemaal net even makkelijker, overzichtelijker en netter. 

Wie mee wil doen met #klooienmetcomputers kan dat doen via GitHub. Maak een account op www.github.com en zoek naar Abmvk/kmc. Het account Abmvk volgen kan ook. Lezers zijn vrij te gebruiken wat ze willen en om zelf zaken toe te voegen of aan te passen, vragen te stellen of commentaar te leveren.