Introduction

Rust est un langage de programmation impératif fortement typé avec une sémantique d'utilisation sûre de la mémoire. Le compilateur Rust génère du code natif.

Le développement de Rust a été influencé par de nombreux autres langages, mais certains aspects de ce dernier sont originaux et spécifiques, notamment le modèle de possession des références à la mémoire, rendant le langage particulièrement adapté au développement de code système sûr et performant.

Ce modèle d'utilisation de la mémoire combine la puissance d'un langage possédant un mécanisme de ramasse-miettes avec la performance d'une gestion manuelle de la mémoire.

Histoire de Rust

  • Exposé de Steve Klabnik
  • Objectif de Rust: concevoir un langage pour la programmation système compilé, concurrent et sûr.
  • Utilisé par Mozilla pour le moteur de rendu web Servo, dont une partie du code est partagé avec le navigateur web Firefox
  • 2006-2016: v1.0. Développement ouvert (initié par Graydon Hoare)
  • Many older languages better than the new ones. We keep forgetting already-learned lessons.
  • Technologies from the past come to save the future from itself.
  • Premier code "Rust" montré à la communauté (syntaxe obsolète):
fn main() {
    log "Hello, world!";
}

fn max(int x, int y) -> int {
    if (x > y) {
        ret x;
    } else {
        ret y;
    }
}
  • Ancien mécanisme pour les objets:
obj counter(int i) {
    fn incr() {
        i += 1;
    }
    fn get() -> int {
        ret i;
    }
}

fn main() {
    auto c = counter(10);
    c.incr();
    log c.get();
}
  • Ancien mécanisme de généricité:
fn swap[T](tup(T,T) pair) -> tup(T,T) {
    ret tup(pair._1, pair._0);
}

fn main() {
    auto str_pair = tup("hi", "there");
    auto int_pair = tup(10, 12);
    str_pair = swap[str](str_pair);
    int_pair = swap[int](int_pair);
}
  • Dans la conception: importance de la sémantique par rapport à la syntaxe
  • D'OCaml à Rust dans LLVM

Ressources utilisées pour ce cours

Toutes les ressources utilisées sont gratuites et libre d'accès, et leurs codes sources sont disponibles sur Github.

Manuels

  • The Rust Programming Language: également appelé "The Rust Book", un livre d'introduction à Rust
  • Rust by Example: une collection d'exemples exécutables pour illustrer différents concepts de Rust et de ses bibliothèques
  • Cookin' with Rust: également appelé the "The Rust Cookbook", des exemples de code pour effectuer des tâches de programmation courantes, utilisant des crates courants (les crates sont des paquetages développés par des tiers)
  • The Rust Reference: la référence du langage, décrivant chaque construction. Ce n'est pas un guide d'intruction mais il est utile pour comprendre précisément certains aspects du langage.

Outils

Ce cours a été fait avec:

  • mdBook qui permet de créer des documentations
  • The Rust Playground qui permet de compiler et d'exécuter du code Rust en ligne et qui possède également une API qui permet de compiler et d'exécuter les exemples du cours

Première étape: installation de Rust et "Hello, world!"

  • Utiliser la page d'installation de Rust pour l'installer sur votre machine.
  • Créer, compiler et exécuter le programme hello.rs suivant:
fn main() {
    println!("Hello, world");
}

Deuxième étape: Rustlings

  • Récupérer et installer les Rustlings (des exercices cours pour apprendre à lire et à écrire du code en Rust)
git clone -b 5.6.1 --depth 1 https://github.com/rust-lang/rustlings
cd rustlings
cargo install --force --path .
  • Continuer les Rustlings en vous servant des manuels ci-dessus
  • À la fin de votre session de travaux pratiques, générez un patch (git diff > p)

Troisième étape: outil d'indexation (baf-core)

baf-core index <repertoire>