De Wyzer Programmeertaal

"Simpelheid is niet de afwezigheid van kracht. Het is kracht zonder pretentie."

— Atiksh Sharma

Motivatie achter Wyzer

Rust garandeert veiligheid binnen één proces, maar biedt geen oplossingen voor:

• Gedistribueerde deadlocks
• Protocolmismatches
• Correctheid tussen verschillende services (cross-service correctness)

Om dit probleem op te lossen introduceert Wyzer het concept van choreografische programmering, wat een van de weinige serieuze pogingen is om deze uitdagingen aan te pakken.

Bijdragen zijn welkom. Als je wilt bijdragen aan de taal, lees dan RESEARCH.md of word lid van onze Discord-server: https://discord.gg/RhpPhkTrVu

Documentatie

Om te leren programmeren in Wyzer, kun je de officiële documentatie raadplegen:

• Introductie
• Variabelen en Typen
• Control Flow (sturingsstructuren)
• Functies en Structs
• Geheugenmodel

Hoe je programmeert in Wyzer

Wyzer is ontworpen om simpel, expliciet en gemakkelijk leesbaar te zijn. Hieronder volgt een kort overzicht van hoe je code schrijft in Wyzer.

1. Variabelen en Typen

Alles heeft een duidelijk type en variabelen zijn standaard onveranderlijk (immutable). Als je een variabele wilt kunnen wijzigen, moet je expliciet var gebruiken in plaats van let. Voor constanten die tijdens het compileren worden vastgesteld, kun je const gebruiken.

fn main() {
    const MAX: u32 = 100;  // Constante bij compilatie
    let x: u32 = 10;       // Kan niet worden gewijzigd
    var y: u32 = 20;       // Kan worden gewijzigd
    y = y + x;
    std::io::println(y);
}

2. Structs en Data

Je kunt eigen datastructuren definiëren en direct toegang krijgen tot hun velden.

struct Point {
    x: u32,
    y: u32
}

fn main() {
    let p: Point = Point { x: 10, y: 20 };
    std::io::println(p.x);
}

3. Control Flow

Wyzer ondersteunt standaard if/else, while en for-loops. Let op dat loops geen haakjes rond de conditie nodig hebben.

fn main() {
    let mut i: u32 = 0;
    while i < 3 {
        std::io::println(i);
        i = i + 1;
    }
}

4. Foutafhandeling en Match

Fouten worden niet verborgen. Functies die kunnen mislukken, geven een Result<T, E> terug. Je gebruikt match-expressies om veilig zowel de succesvolle (Ok) als de foutieve (Err) gevallen af te handelen. Let op dat match een expressie is; wanneer deze als een op zichzelf staande statement wordt gebruikt, is een puntkomma aan het einde vereist.

fn main() {
    let result: Result<u32, str> = Ok(42);
    match (result) {
        Ok(value) => std::io::println(value),
        Err(err_msg) => std::io::println(0)
    };
}

FAQ: Wat het is, waarom het bestaat en wat er daadwerkelijk nieuw is

Een eenvoudige gids zonder wiskunde om het project snel uit te leggen.

1. Wat is Wyzer in één alinea?

Wyzer is een programmeertaal gebouwd op één idee: de meeste complexe problemen (zoals geheugenfouten, deadlocks en netwerkfouten) ontstaan omdat het onduidelijk is wie een resource bezit. In plaats van drie verschillende instrumenten te gebruiken om geheugen, concurrency en netwerken te repareren, gebruikt Wyzer één enkele eigendomsregel (ownership rule) voor deze drie zaken.

2. Waarom überhaupt een nieuwe taal maken?

Het eerlijke antwoord begint bij wat er al goed is aan bestaande opties:

• Rust bewees dat veilig geheugenbeheer mogelijk is zonder garbage collector. Dit is geweldig, maar Rust is moeilijk te leren en de regels maken sommige gangbare codestructuren lastig te schrijven.
• Go, Java, C# en Python gebruiken garbage collectors. Dit maakt ze gemakkelijker in gebruik, maar trager en minder voorspelbaar, wat nadelig is voor real-time of low-level systemen.
• Netwerkprogrammering gebeurt nog steeds grotendeels handmatig. Je schrijft twee programma's en hoopt dat ze correct met elkaar communiceren; wanneer dat niet zo is, ontstaan er bugs.

Het doel van Wyzer is om de veiligheid van Rust te bieden zonder de complexiteit, en dezelfde regel te gebruiken om ook netwerkprogramma's veilig te maken.

3. Wat is er daadwerkelijk nieuw?

De meeste onderdelen van Wyzer bestaan al; het nieuwe is de combinatie ervan:

• Perceus reference counting: Snel geheugenbeheer zonder de complexiteit van Rust (overgenomen van Koka en Lean 4).
• Choreografische programmering: Het schrijven van één netwerkregel die code genereert voor elke computer (gebaseerd op academisch onderzoek).

Het innovatieve aspect: Wij gebruiken het choreografie-concept niet alleen voor netwerken, maar ook voor threads en interrupts. Dezelfde regel bewijst de veiligheid voor geheugen, interrupts én het netwerk. Het voordeel is dat je slechts één regel hoeft te leren om deze drie zaken veilig te beheren.

4. Kernprincipes van het ontwerp

• Eén manier om iets te schrijven: Als er twee manieren zijn om hetzelfde resultaat te bereiken, verwijderen we er één.
• Geen verborgen magie, maar houd het schoon: Belangrijke zaken moeten zichtbaar zijn in de code, zonder dat je overbodige boilerplate hoeft te schrijven.
• Laat de compiler het werk doen, tenzij dit verwarrend is: We willen dat de compiler zaken uitzoekt, maar eisen duidelijke regels wanneer zaken complex worden.
• Eerlijk zijn over wat niet af is: Onopgeloste problemen worden duidelijk gemarkeerd.

5. De kernsemantiek in begrijpelijke taal

• Geheugen (Sectie 5): Je schrijft functionele code die data niet wijzigt. Achter de schermen past de compiler de data direct in het geheugen aan als er slechts één eigenaar is. Dit maakt het zo snel als C, zonder garbage collector of lifetime-regels.
• Ownership is alles (Secties 3, 6, 7): De basisregel is dat zodra je een resource gebruikt, je deze niet meer kunt gebruiken. Dit geldt voor geheugen, netwerkberichten en hardware-interrupts.
• Veilige netwerken (Sectie 6): Je schrijft reguliere functies en de typen geven aan wie de data bezit. De compiler bepaalt de netwerkregels en controleert deze, waardoor deadlocks en verloren berichten worden opgevangen voordat de code wordt uitgevoerd.
• Geen verborgen control flow: Er is geen async/await-splitsing. Fouten worden teruggegeven als standaard typen, niet als verborgen exceptions.

6. Veelgestelde vragen

"Is dit niet gewoon Rust met extra stappen?" Nee. We willen de veiligheid van Rust zonder de steile leercurve. We gebruiken een andere methode (Perceus) voor geheugen en Rust heeft onze netwerkfuncties niet.

"Is choreografische programmering geen opgelost onderzoeksgebied?" De wiskunde klopt, maar het wordt vooral in onderzoek gebruikt, niet in echte talen. Wij willen dit brengen naar een algemene programmeertaal.

"Waarom niet gewoon effect handlers / async-await / een GC gebruiken zoals iedereen?" Die tools lossen specifieke problemen op. Wyzer onderzoekt of één enkele regel tegelijkertijd geheugen, threads en netwerken kan oplossen.

"Wordt dit daadwerkelijk afgemaakt of productieklaar?" Eerlijk gezegd is dit vroegtijdig onderzoek. Verschillende grote problemen zijn nog onopgelost.

"Wat is de elevator pitch, nog één keer?" Eén ownership-regel voor geheugen, threads en netwerken. Geen garbage collector, geen complexe borrow checker en geen netwerkfouten.

AI-ondersteuning

AI is ingezet voor de volgende zaken:

• Het genereren van commit-berichten.
• Onderzoek (het nauwkeurig begrijpen van choreografische programmering, het Perceus-geheugenmodel, etc.).
• Brand design: AI hielp bij het bedenken van ideeën voor het logo van Wyzer.

Opmerkelijke voorbeelden

• donut.wyz: De beroemde torus (ook bekend als de donut), herschreven in Wyzer. Beschikbaar op: https://github.com/rudywasfound/donut.wyz