Le duo comique

le CPU, zone de non-droit

• exécution directe sur CPU
• manipulation directe de la mémoire
• intégration avec d'autres applications

Pourquoi un langage bas-niveau ?

• driver kernel
• bibliothèque importable dans d’autres langages
• indépendance du GC et de ses pauses
• embarquer dans un langage à GC

Les langages Old School

• C
• C++
• Fortran

Aucune assurance

• Pas de vérification du format des données
• gestion d’erreurs ardue
• null pointer dereference
• buffer overflows
• heap overflows
• double free
• etc.

Y a pas de bug dans mon code

Program received signal SIGSEGV, Segmentation fault.
0x1c0007a8 in main () at main.c:6

Buts du langage

• bas niveau
• portable
• memory safe
• concurrence
• parallélisme

Memory safe

• gérer la mémoire à la place du développeur
• supprimer des classes de bugs entières dans le compilateur

    Do not kill bugs, kill bug classes

Un monde sans GC ?

3 méthodes de stockage de données:

• statique (dure aussi longtemps que le process)
• stack (dure aussi longtemps que le bloc courant)
• heap (zone mémoire allouée et relâchée à la demande)

Statique

fn main() {
  println!("hello world");
}

Stack

fn f() -> &uint {
  let s = 1;
  let r = &s;
  r
}
fn main() {
  println!("{}", f());
}

static.rs:3:11: 3:13 error: `s` does not live long enough
static.rs:3   let r = &s;

Stack: l'erreur complète

static.rs:3:11: 3:13 error: `s` does not live long enough
static.rs:3   let r = &s;
                      ^~
static.rs:1:17: 5:2 note: reference must be valid for the
anonymous lifetime #1 defined on the block at 1:16...
static.rs:1 fn f() -> &uint {
static.rs:2   let s = 1;
static.rs:3   let r = &s;
static.rs:4   r
static.rs:5 }
static.rs:1:17: 5:2 note: ...but borrowed value is only
valid for the block at 1:16
static.rs:1 fn f() -> &uint {
static.rs:2   let s = 1;
static.rs:3   let r = &s;
static.rs:4   r
static.rs:5 }
error: aborting due to previous error

Heap

fn f() -> ~str {
  let s = ~"hello world";
  s
}
fn main() {
  println!("{}", f());
}

Ownership

fn main() {
  let s = ~"hello world";
  spawn(proc() {
    println!("other task: {}", s);
  });
  println!("main task {}", s);
}

borrow.rs:6:28: 6:29 error: use of moved value: `s`
borrow.rs:6   println!("main task {}", s);
                                       ^
[...]
borrow.rs:3:9: 5:4 note: `s` moved into closure environment
here because it has type `proc:Send()`,which is non-copyable
(perhaps you meant to use clone()?)
borrow.rs:3   spawn(proc() {
borrow.rs:4     println!("other task: {}", s);
borrow.rs:5   });

Ca peut être unsafe

use std::cast;
let mut x: u8 = 1;

let ref_1: &mut u8 = &mut x;
let ref_2: &mut u8 = unsafe {
  cast::transmute_mut_region(ref_1)
};

// ref_1 et ref_2 pointent vers la même zone mémoire
*ref_1 = 10;
*ref_2 = 20;

On peut écrire de l'assembleur

fn add(a: int, b: int) -> int {
  let mut c = 0;
  unsafe {
    asm!("add $2, $0"
         : "=r"(c)
         : "0"(a), "r"(b)
         );
  }
  c
}

GC

Ca existe, mais...

Que propose Rust?

• données immutables par défaut, mutables à la demande
• gestion du scope d’une variable (ajout automatique de malloc/free)
• gestion de l’ownership (on ne peut modifier une zone mémoire gérée par un autre thread)
• les manipulations non vérifiables sont isolées

Concurrence

• Modèle CSP-ish
• sync/async
• channels typés
• ownership
• Mode M:N ou 1:1

Lancer une task

fn print_message() { println!("Hello!"); }
spawn(print_message);

Channels

let (tx, rx): (Sender<int>, Receiver<int>) = channel();

spawn(proc() {
  let result = 1;
  tx.send(result);
  println!("result sent");
});

sleep(200);
let result = rx.recv();
println!("result: {}", result);

Ownership

let (tx, rx) = channel();

for init_val in range(0u, 3) {
  let child_tx = tx.clone();
  spawn(proc() {
    child_tx.send(init_val);
    sleep(1000 - (init_val as u64) * 100);
    println!("sent computation result: {}", init_val);
  });
}

let result = rx.recv() + rx.recv() + rx.recv();
println!("result: {}", result);

Futures

  let mut future = sync::Future::spawn( proc() {
    partial_sum(ind)
  });

  sleep(200);
  println!("result: {}", ft.get());

Patterns

• Pipeline
• Pub-sub

Let it crash

Mutabilité par défaut == optimisation prématurée

L’immutabilité

• Structure de données persistentes
• Raisonnement simplifié
• Thread safety
• Optimisations possibles

Système de types

• Typage statique
• Typage fort (whatever it means)
• Garanties statiques sur l'exécution

Système de types

• Polymorphisme paramétrique (génériques)
• Type system expressif

Aller plus loin

• Durée de vie des variables
• Structures de contrôle typées
• Propagation de la mutabilité

Structures de données

• Structs (product type)

pub struct Point {
    pub x: int,
    pub y: int
}

pub struct Circle {
    pub center: ~Point,
    pub radius: uint
}

Structures de données

• Enums (sum type)

pub enum Json {
    Number(f64),
    String(~str),
    Boolean(bool),
    List(List),
    Object(~Object),
    Null,
}

pub type List = ~[Json];
pub type Object = TreeMap<~str, Json>;

Pattern matching

• Énumération
• Déconstruction

match jsonValue {
    Number(n) => ...
    String(s) => ...
    ...
}

Traits

• Séparation données / fonctions

impl Circle {
    pub fn radius(&self) -> f64 {
        f64::consts::PI * self.radius * 2
    }
}

Typeclass pattern

• Factorisation des comportements

pub trait Show {
    fn fmt(&self, &mut Formatter) -> Result;
}
impl fmt::Show for Circle {
    fn show(&self, fmt: &mut ftm::Formatter) -> float {
        write!(fmt.buf, ...)
    }
}

Traits de base

• Eq pour l'égalité (auto-implémentable)
• Ord pour la comparaison
• Hash pour les condensats (auto-implémentable)
• … et beaucoup d'autres !

Auto implémetation

#[deriving(Eq, Clone, Show)]
pub struct Point {
    pub x: f64,
    pub y: f64
}

#[deriving(Eq, Clone, Show)]
pub struct Circle {
    pub center: ~Point,
    pub radius: f64
}

Polymorphisme paramétrique

pub enum Option<T> {
    None,
    Some(T)
}

Polymorphisme paramétrique + traits

• Types génériques
• + contraintes spécifiques

Typeclass pattern

impl<A:ToJson> ToJson for Option<A> {
    fn to_json(&self) -> Json {
        match *self {
          None => Null,
          Some(ref value) => value.to_json()
        }
    }
}

Crates, modules, etc

• Crate <=> bibliothèques
• Imports explicites
• Pas de fuites

Crates, modules, etc

• Crate <=> bibliothèques
• Imports explicites
• Pas de fuites