Jeudi 19 mars 2015, Ippon Technologies tenait une conférence sur le langage Rust dans leurs locaux. Petit retour sur cette présentation de Mathieu Poumeyrol et Pierre Baillet, 2 ingénieurs provenant de Centrale Paris... Langage fonctionnel orienté-objet, Rust fut au départ inventé pour permettre des développements de bas niveau avec un langage plus orienté Objet, plus fonctionnel, et avec une plus faible courbe d'apprentissage que le C ou le C++ tout en gardant les avantages de ces derniers : performant, portable et embarqué. 

Rust est à l'origine un programme de recherche de la fondation Mozilla, mais le projet est complètement open-source et une grande partie des commits effectués sur le github de Rust proviennent de la communauté.

Comme Scala, Rust implémente les fonctionnalités impératives communes (fonctions, boucles, conditions, etc...) mais dispose aussi de multiples features fonctionnelles :

$1·    Closures

$1·    Immutables

$1·    Inférence de type

$1·    Pattern matching

$1·    Macros

$1·    ...

La grosse différence avec Scala est que, comme en C et en C++, Rust permet l'utilisation de pointeurs, vous permettant ainsi de gérer vous même vos allocations mémoire.

"Arg, des pointeurs, plus de travail pour corriger les problèmes de fuite mémoire" me direz vous...

Et bien pas vraiment, et ce pour 2 raisons:

D'une, Rust utilise une syntaxe bien plus simple que le C et le C++ pour traiter ses pointeurs et les désallouent automatiquement quand vous sortez du scope de leur utilisation. Par exemple en C, vous pourriez avoir le code suivant :

{

    int* x;

    x=(int*)malloc(sizeof(int));

    *x = 5 ;  

    // Votre code

    free (x );

}

En Rust, cela donne ça :

{

    let x = Box ::new ( 5);

    // Votre code

}

La deuxième raison est que le compilateur de Rust (qui est un compilateur LLVM si ça vous parle) est très exigeant et que l'ensemble du système de possession est déterminé par le compilateur. En cas de problème d'accès à une variable non possédée, ou si une variable ne se voit jamais libérée sans que ce soit explicitement défini, votre code ne compilera pas. Cela permet entre autres d'éviter les problèmes de "buffer overflow" que vous pourriez rencontrer en C ou C++.

Maintenant que nous avons pu voir un peu de quoi retourne Rust, il est temps de se plonger un peu dans du code.

// l' équivalent d'une classe

struct Point {

    // Nos variables sont des entiers de 32bits

    x : i32 ,

    y : i32 , // la virgule est voulue

}

// un trait est une sorte d'interface

traitHasxEqualsy{

    fnxEqualsy(&self)->boolean;

}

// les méthodes sont d éfinies dans l'implé mentation.

// Ici, on implémente notre trait pour notre structure.

impl HasxEqualsy for Point {

    // Une fonction qui doit retourner un booléen.

    // Comme en python, le &self est de mise.

    fnxEqualsy(&self)->boolean{

         self.x==self.y

    }

}

// Une fonction

fn main() {

    // Instanciation d'un pointeur de type Point mutable.

    // Les variables ne sont pas mutables par défaut.

    let mut point = Box:: new (Point {x : 0, y : 0 } );

    increment (point . x);

    // Definition d'un closure appelant la macro println.

    // {:?} permet à la fois de binder une variable et de d éfinir que la macro

    // ne sera appelé e qu'en mode de debug.

    let printer = || { println! ( "x = {:?}, y = {:?}" , point .x , point. y); } ;

    // Utilisation de notre closure

    printer ();

} // point est d étruit

// incrémente le point. Notez la pr ésence du mut

fn increment (point : &mut Point) {

    point .x += 1;

    point .y += 1;

}

Voilà pour une présentation très rapide de Rust au niveau du code. Bien sûr, il existe énormément d'autres fonctionnalités mais que je ne montrerai pas ici.

 Mon avis

Mon impression de Rust est vraiment bonne, les benchmarks sont très positifs avec des temps se rapprochant du C et 3 à 4 fois plus rapide qu'en Java et le code me paraît clair et concis en rapprochant les langages C de Scala et des autres langages multi-paradigmes. Bien que je ne sois pas un développeur C, C++ ou autre langage de bas niveau, je vois donc bien l'attrait de Rust.

Je ne suis cependant pas près de l'utiliser.

D'une, il ne m'est pour le moment jamais arrivé d'avoir a travailler sur un programme avec des problématiques d'optimisation de la consommation mémoire. Je vois cependant l'intérêt que Mozilla peut avoir pour un langage qui leur permettrait d'optimiser leur navigateur tout en ayant un langage évolutif et maintenable, ainsi que pour l'industrie du jeux vidéo, qui tourne toujours beaucoup sur les langages C.

Ensuite, le langage est encore très jeune. Certes il a beaucoup de potentiel, mais une version sort actuellement toutes les 6 semaines et il arrive apparemment régulièrement que le langage ait été modifié au point de casser complètement la compatibilité avec les versions précédentes, même si cette tendance diminue fortement avec l'arrivée en août de la version 1.0.

Enfin, le langage dispose pour le moment d'encore peu de librairies, les principales étant assez simples et orientées vers le jeu vidéo, ou en concurrence avec d'autres plugins. Il existe par exemple un connecteur pour MySql, un pour mongoDB, mais pas pour Oracle.

En conclusion, Rust est un langage apportant de nombreuses perspectives excitantes aux développeurs de bas-niveau. Pour les autres, et principalement les développeurs Java, Scala reste le langage de prédilection pour la programmation fonctionnelle. Rust est également très jeune, beaucoup trop jeune pour l'utiliser dans un contexte professionnel, mais avec un gros potentiel.

Si vous êtes intéressés, c'est le moment parfait pour commencer à développer des librairies qui, avec un peu de chance et de talent, feront peut être parties des librairies principales de Rust.

Personnellement, je vais continuer à surveiller, de loin, ce nouveau langage qui peut apporter de nombreuses nouveautés dans le monde du jeu vidéo et autres mondes fortement liés à la performance et à la consommation mémoire...