Waarom je Rust zou moeten leren: De voordelen en uitdagingen

Rust is een relatief nieuwe taal, maar wint snel aan populariteit door zijn focus op veiligheid, snelheid en betrouwbaarheid. Het is een statisch getypeerde taal die zich richt op het vermijden van veel voorkomende fouten, zoals geheugencorruptie en race-voorwaarden, die in andere talen vaak leiden tot moeilijk te traceren bugs. Voor ontwikkelaars die gewend zijn aan dynamische talen zoals Python, Perl, of JavaScript, kan Rust een uitdagende overstap lijken. Rust vereist een goed begrip van het geheugensysteem van de computer en maakt intensief gebruik van typecontrole. Deze striktheid kan aanvankelijk ontmoedigend overkomen, maar uiteindelijk levert het veel voordelen op.

Daarnaast biedt Rust de mogelijkheid om applicaties te ontwikkelen die gemakkelijk te delen zijn, zonder dat je afhankelijk bent van specifieke versies van een runtime, zoals bij Python. Wanneer je een programma in Python schrijft, moet de ontvanger de juiste versie van Python en de benodigde pakketten hebben geïnstalleerd. In tegenstelling tot dat, compilet Rust je code naar een standalone uitvoerbaar bestand dat direct kan worden uitgevoerd, zolang het op de juiste architectuur draait. Dit maakt het veel eenvoudiger om Rust-programma's naar collega's of gebruikers te distribueren.

De mogelijkheid om kleinere en efficiëntere containers te maken met Rust is ook een groot pluspunt. Bij het werken met Docker of Singularity zijn de containers voor Rust-programma’s vaak vele malen kleiner dan die voor Python. Dit maakt Rust een uitstekende keuze voor toepassingen waarbij prestaties en ruimtegebruik belangrijk zijn. Een eenvoudige Linux-container met een Rust-binaire is vaak slechts enkele tientallen megabytes groot, vergeleken met de honderden megabytes die je nodig hebt voor een Python-container met de bijbehorende runtime.

Bovendien biedt de Rust-ecosysteem een rijk aanbod van modules, zogenaamde "crates", die eenvoudig te vinden en goed gedocumenteerd zijn. Dit maakt Rust niet alleen krachtig, maar ook erg productief. Als je op zoek bent naar libraries voor uiteenlopende toepassingen, zul je merken dat de documentatie op Docs.rs zeer behulpzaam is en je snel op weg helpt. Dit alles draagt bij aan het feit dat Rust niet alleen een veilige keuze is, maar ook een uiterst productieve taal voor softwareontwikkeling.

De uitdagingen van het leren van Rust zijn echter niet te negeren. De taal vereist een goed begrip van de onderliggende systemen, zoals geheugentoewijzing en pointerbeheer. Dit maakt het voor beginners moeilijker om snel aan de slag te gaan, zeker als je niet bekend bent met deze concepten. Rust verplicht je echter niet om deze details te begrijpen om aan de slag te gaan, maar het biedt wel voldoende tools om ze effectief te gebruiken zodra je meer geavanceerde code schrijft.

Dit boek richt zich op de praktische aspecten van Rust en biedt een reeks programmeeruitdagingen die je stap voor stap door de taal leiden. Door deze uitdagingen aan te pakken, zul je niet alleen leren hoe je Rust-programma's schrijft, maar ook hoe je ze test en optimaliseert. Testen zijn cruciaal in Rust, zowel om de werking van je code te verifiëren als om een systematische benadering van probleemoplossing te ontwikkelen. Het schrijven van tests vóór het schrijven van de code, oftewel Test-Driven Development (TDD), helpt niet alleen bij het garanderen van de correctheid van de code, maar ook bij het verfijnen van je ontwerp en logica.

Hoewel de uitdagingen in dit boek afkomstig zijn van de Unix command-line coreutils, zijn ze ontworpen om fundamentele programmeerprincipes te onderwijzen die overal van toepassing zijn. Door te werken aan deze kleine programma's, zoals head en tail, leer je niet alleen de kracht van Rust, maar ook de basisprincipes van systeemprogrammering. Deze programma's zijn bekend en bieden een solide basis voor leren, terwijl ze tegelijkertijd ruimte bieden voor diepgaande verkenning van de taal.

Hoewel de meeste uitdagingen in dit boek afkomstig zijn van Unix-programma's, is het belangrijk om te begrijpen dat de basistechnieken die je leert niet beperkt zijn tot die specifieke toepassingen. Het doel is om een bredere vaardigheid in Rust op te bouwen die je kunt toepassen op allerlei soorten projecten. Deze benadering helpt je niet alleen bij het leren van Rust, maar ook bij het ontwikkelen van een systematische en gestructureerde benadering van softwareontwikkeling.

Wanneer je met Rust werkt, zal je merken dat het programma meestal goed werkt zodra het gecompileerd is. De compiler zorgt ervoor dat veel van de potentieel destructieve fouten al bij de ontwikkeling worden afgehandeld, waardoor de kans op runtime-fouten afneemt. Dit maakt Rust tot een uitstekende keuze voor softwareprojecten waarbij betrouwbaarheid en prestaties van het grootste belang zijn.

Hoe verwerk je commandoregelargumenten correct in een Rust-programma met clap?

Het opzetten van een solide structuur voor het verwerken van commandoregelargumenten is cruciaal bij het ontwikkelen van CLI-programma’s in Rust. In het bijzonder wanneer je een programma schrijft dat lijkt op tail, waar de gebruiker moet kunnen specificeren hoeveel regels of bytes van het einde van een bestand gelezen moeten worden. De uitdaging ligt in het correct modelleren van de opties, het afdwingen van exclusiviteit tussen argumenten, het afhandelen van standaardwaarden, en het correct parsen van invoerwaarden die zowel positief als negatief kunnen zijn.

Het gebruik van de clap crate is hiervoor een uitstekende keuze. Door gebruik te maken van Command::new, kunnen we onze argumenten declaratief opzetten. Zo wordt bijvoorbeeld het bestandspad als een verplicht positioneel argument opgegeven, terwijl de opties --lines en --bytes als wederzijds exclusieve alternatieven gedefinieerd zijn. Deze exclusiviteit kan worden afgedwongen met .conflicts_with(...), of op een meer structurele manier via een ArgGroup.

Het programma moet standaard de laatste 10 regels van een bestand tonen, tenzij expliciet bytes worden opgegeven met de -c of --bytes optie. De stille modus wordt geactiveerd met de -q vlag, waarbij kopteksten tussen meerdere bestanduitvoer worden onderdrukt. Dit alles wordt elegant geparset en gebundeld in een Args struct die eenvoudig door de rest van het programma gebruikt kan worden.

Een belangrijk aandachtspunt is de validatie van numerieke argumenten. In tegenstelling tot head, waar alleen positieve aantallen rijen of bytes werden verwacht, moet deze tail-variant ook negatieve waarden ondersteunen, net als in de originele Unix-versie. Hiervoor is een aangepaste parser nodig, die de invoer als String accepteert en vervolgens omzet naar een TakeValue enum.

De TakeValue enum is zorgvuldig ontworpen om drie semantisch verschillende gevallen te onderscheiden: positieve nul (+0), reguliere gehele waarden (positief of negatief), en de speciale betekenis van nul zonder teken. Deze laatste geeft in de context van het programma aan dat er niets moet worden geselecteerd, terwijl +0 juist betekent dat alles moet worden weergegeven – een subtiel maar belangrijk verschil.

De parser zelf moet alle reguliere gehele getallen aanvaarden, inclusief de uiterste grenzen van een 64-bit integer, met passende foutmeldingen voor ongeldige invoer zoals kommagetallen of tekstuele strings. Dit wordt ondervangen in de testmodule, waar grondige tests zijn opgenomen voor alle verwachte randgevallen, inclusief overflows en foutieve formaten. Hierdoor blijft het gedrag voorspelbaar en betrouwbaar onder alle omstandigheden.

Het gebruik van anyhow::Result in de main functie biedt een uniforme foutafhandeling en maakt het eenvoudiger om fouten consistent te loggen of het programma met een gepaste exitcode te laten stoppen. De run functie wordt hiermee het hoofdentrypunt voor de kernlogica, wat ook het testen en hergebruik vergemakkelijkt.

Verder moet men zich bewust zijn van het verschil tussen een commandoregelprogramma dat stdin verwerkt versus bestanden als argumenten vereist. In dit specifieke geval is ervoor gekozen om stdin niet te ondersteunen zonder expliciet bestand, wat het gedrag voorspelbaar maakt. Maar dit moet expliciet worden afgevangen in de validatiefase met een duidelijke foutmelding.

Bij het bouwen van CLI-tools in Rust is deze aanpak met clap, gecombineerd met sterk getypeerde enums en rigoureuze testgedreven ontwikkeling, een betrouwbare manier om controle, betrouwbaarheid en gebruiksvriendelijkheid te waarborgen.

Hoe definieer je de argumenten en gebruik je pseudo-willekeurige getallen in Rust?

Wanneer je een nieuw Rust-project begint, is het belangrijk om eerst de nodige afhankelijkheden toe te voegen aan je Cargo.toml. Deze afhankelijkheden stellen je in staat om een robuust programma te schrijven dat omgaat met gebruikersinvoer, willekeurige getallen, en reguliere expressies. Begin met het maken van een nieuw project door het commando cargo new fortuner uit te voeren. Voeg vervolgens de volgende afhankelijkheden toe aan je Cargo.toml:

toml
Copy code
[dependencies]
anyhow = "1.0.79"
clap = { version = "4.5.0", features = ["derive"] }
rand = "0.8.5"
regex = "1.10.3"
walkdir = "2.4.0"
[dev-dependencies]
assert_cmd = "2.0.13"
predicates = "3.0.4"
pretty_assertions = "1.4.0"

De volgende stap is het definiëren van de argumenten die je programma zal accepteren. Dit doe je door de struct Args te definiëren, die de verschillende argumenten van de opdrachtregel zal bevatten. In het onderstaande voorbeeld zie je hoe je de argumenten in Rust kunt definiëren met behulp van de clap-bibliotheek:

rust
Copy code
#[derive(Debug)]

pub struct Args {
    sources: Vec<String>,
    pattern: Option<String>,
    insensitive: bool,
    seed: Option<u64>,
}

De sources-parameter is een lijst van bestanden of directories. Het pattern is een optionele string waarmee we de 'fortune' kunnen filteren. De insensitive-vlag bepaalt of het patroon hoofdlettergevoelig is. De seed is een optionele u64 waarde die gebruikt zal worden voor willekeurige selectie.

Het is belangrijk om deze struct correct te koppelen aan de opdrachtregelargumenten, wat je kunt doen met behulp van clap's builder- of derive-patroon. Hier is een voorbeeld van de get_args functie die de argumenten leest:

rust
Copy code
fn get_args() -> Args {

    let matches = Command::new("fortuner")
        .version("0.1.0")
        .author("Ken Youens-Clark")
        .about("Rust versie van `fortune`")
        .get_matches();
    Args {
        sources: ...,
        seed: ...,
        pattern: ...,
        insensitive: ...,
    }
}

Zodra de argumenten zijn gedefinieerd, moet je ervoor zorgen dat de programma-uitvoer het juiste gebruik en de juiste opties toont. Als je bijvoorbeeld cargo run -- -h uitvoert, moet je een overzicht van de beschikbare opties zien:

bash
Copy code
$ cargo run -- -h

Rust versie van `fortune`
Gebruik: fortuner [OPTIES] ...
Argumenten:
  ...  Invoerbestanden of directories
Opties:
  -m, --pattern   Patroon
  -i, --insensitive   Hoofdletterongevoelige patroonmatching
  -s, --seed   Willekeurige seed
  -h, --help   Print hulp
  -V, --version   Print versie

Let op dat het programma minimaal één invoerbestand of directory vereist. Als er geen argumenten worden meegegeven, moet het programma stoppen en een foutmelding tonen, zoals:

bash
Copy code
$ cargo run
error: de volgende vereiste argumenten werden niet verstrekt:
  ...
Gebruik: fortuner ...
Meer informatie? Probeer '--help'.

Een belangrijk onderdeel van de opdracht is het gebruik van een pseudo-willekeurig getalgenerator (PRNG). Dit wordt gedaan om willekeurige keuzes te maken, maar aangezien echte willekeurigheid moeilijk te verkrijgen is in een computer, gebruiken we een seed om de willekeurige reeks voorspelbaar te maken. Hierdoor kunnen we testen door een bekende seed te gebruiken en te verifiëren dat de verwachte output wordt geproduceerd. Dit is een essentieel concept in veel toepassingen die afhankelijk zijn van willekeurige getallen.

Het is belangrijk om een juiste foutbehandeling te implementeren, bijvoorbeeld wanneer de ingevoerde seed geen geldig getal is. Als de seed geen geldig u64 getal is, moet je een foutmelding geven:

bash
Copy code
$ cargo run -- ./tests/inputs -s blargh
error: ongeldig waarde 'blargh' voor '--seed': ongeldige cijfer gevonden in string

rust
Copy code
fn run(args: Args) -> Result<()> {
    let pattern = args
        .pattern
        .map(|val: String| {
            RegexBuilder::new(val.as_str())
                .case_insensitive(args.insensitive)
                .build()
                .map_err(|_| anyhow!(r#"Ongeldig --pattern "{val}""#))
        })
        .transpose()?;
    println!("{pattern:?}");
    Ok(())
}

Verder moet je het programma ook uitbreiden met functionaliteit om bestandspaden te lezen en de willekeurige regels te selecteren op basis van de gegeven argumenten. De rand-bibliotheek kan worden gebruikt om de willekeurige selectie te implementeren, en met de walkdir-bibliotheek kun je bestanden in directories doorlopen.

Het is niet voldoende om alleen een lijst van bestandspaden te accepteren. Je moet ook rekening houden met foutafhandelingsmechanismen, zoals de controle of een pad daadwerkelijk bestaat, of dat het bestand leesbaar is, etc.

Hoe kun je bestanden vinden en weergeven in een Rust-programma?

In de wereld van commandoregelprogramma's is het vinden en weergeven van bestanden en mappen een essentieel onderdeel van de functionaliteit. In dit geval gaan we kijken naar de implementatie van een eenvoudige versie van het bekende Unix-commando ls in Rust. Dit programma biedt de mogelijkheid om bestanden en directories te vinden en weer te geven, met de optie om verborgen bestanden op te nemen of om lange lijstweergaven te tonen.

De kern van de oplossing ligt in de manier waarop je de argumenten verwerkt. Bij het uitvoeren van het programma zonder argumenten, krijgt het programma een lijst met paden die standaard de huidige werkdirectory vertegenwoordigt. Deze paden kunnen vervolgens worden uitgebreid met verschillende vlaggen zoals --long voor gedetailleerde informatie en --all voor het weergeven van verborgen bestanden. Het programma zal dan de bijbehorende bestanden en directories weergeven.

De verwerking van de argumenten gebeurt met behulp van de clap-bibliotheek, waarmee we eenvoudig commandoregelargumenten kunnen definiëren en verwerken. Hier wordt een functie gedefinieerd die de argumenten verwerkt, namelijk get_args. Deze functie definieert de drie belangrijkste argumenten: paths (de bestanden of directories die we willen weergeven), long (of we gedetailleerde informatie willen zien) en all (of we verborgen bestanden willen opnemen).

De get_args-functie verwerkt de argumenten door ze te lezen en de bijbehorende opties in een struct Args te plaatsen, die de waarde van de paden en de booleaanse waarden voor de vlaggen bevat. Deze functie maakt gebruik van de Command-struct van de clap-bibliotheek en retourneert een struct met de benodigde waarden. De struct Args bevat de drie belangrijke velden die ons in staat stellen om het gedrag van het programma verder te configureren.

Zodra de argumenten zijn verwerkt, is het tijd om de bestanden te vinden. De volgende stap is om te begrijpen hoe de find_files-functie werkt, die verantwoordelijk is voor het zoeken naar de opgegeven bestanden of directories. Deze functie ontvangt de lijst met paden en de optie om verborgen bestanden weer te geven. Het gebruikt de standaardbibliotheek van Rust, met name de module std::fs, om bestandsmetadata op te vragen en te controleren of het opgegeven bestand of de directory bestaat. Wanneer een bestand wordt gevonden, wordt dit bestand toegevoegd aan de lijst van gevonden bestanden.

Het zoeken naar bestanden kan verder worden uitgebreid om verborgen bestanden op te nemen. Dit wordt geregeld door de show_hidden-vlag. Als deze vlag is ingesteld, worden bestanden die beginnen met een punt (zoals .git of .hiddenfile) ook weergegeven. De verwerking van bestandsnamen is van groot belang, vooral als het gaat om het negeren of weergeven van verborgen bestanden. Dit kan door te controleren op de aanwezigheid van een punt aan het begin van de bestandsnaam.

Het programma bevat ook enkele tests die de werking van de find_files-functie controleren. In de tests wordt gecontroleerd of het programma wel of geen verborgen bestanden weergeeft, afhankelijk van de ingestelde vlag. De tests zijn bedoeld om te garanderen dat de implementatie correct werkt en dat de verwachte resultaten worden behaald, ongeacht de volgorde van de gevonden bestanden.

Er is echter nog een belangrijk aspect om te begrijpen bij het werken met bestanden in een dergelijk programma. De manier waarop bestanden en directories worden behandeld in Rust is sterk afhankelijk van het besturingssysteem en het bestandssysteem waarop het programma wordt uitgevoerd. Het resultaat van de find_files-functie kan dus variëren, afhankelijk van de onderliggende systeemstructuur. Dit is iets om rekening mee te houden bij het ontwikkelen van dergelijke programma's, vooral als ze op verschillende systemen moeten draaien.

Ook het omgaan met fouten speelt een grote rol. Het programma moet in staat zijn om fouten op een verantwoorde manier af te handelen, vooral bij het zoeken naar bestanden. Dit kan betekenen dat je de juiste foutberichten moet weergeven als een bestand of directory niet gevonden kan worden, of als een andere fout optreedt tijdens het verwerken van de bestanden. Het correct verwerken van fouten is essentieel voor de robuustheid van het programma.

Daarnaast kan het zinvol zijn om verdere optimalisaties door te voeren in de zoekfunctionaliteit. Een mogelijke uitbreiding zou kunnen zijn om ook subdirectories door te zoeken (recursive search), wat een veelgebruikte functionaliteit is in tools zoals ls in Linux. Hierdoor kan het programma niet alleen bestanden in de opgegeven directories vinden, maar ook in alle onderliggende directories.

Tenslotte, het is belangrijk om te begrijpen hoe je de resultaten van het bestand zoeken op een zinvolle manier presenteert. Naast het simpele lijstformaat, kan een langere lijstweergave (long flag) gedetailleerdere informatie tonen, zoals bestandsrechten, grootte en wijzigingsdatum. Dit is een belangrijke toevoeging aan de functionaliteit van het programma, die het meer geschikt maakt voor uitgebreide bestandssystemen waar gebruikers gedetailleerdere informatie nodig hebben.