Ma première fois au Ch’ti Jug
Ma résolution pour ma dernière année universitaire était d’assister une fois par mois à un évènement axé sur l’informatique et le dev. Dans l’idée, simple. Faisable. Mais je ne l’avais jamais mis en place (pour des raisons multiples et variées qu’un article de blog n’est pas en capacité de contenir).
Donc cette année, je me le suis imposé. J’avais téléchargé MeetUp, noté dans mon agenda de trouver un évènement, et j’ai reçu la notification :
- “Programmé à l’instant : La rentrée du Ch’ti Jug avec Rust”
Une notification a rarement été autant faite pour moi.
Un peu de background
Ça faisait tout pile une semaine que j’avais commencé à apprendre Rust. À l’université, j’ai un projet de groupe en cours qui consiste à développer un émulateur de micro-processeur. Incroyable, non ? On avait tout un énoncé à suivre, et une seule contrainte : ne pas utiliser Java, ou JavaScript, ou quoi que ce soit autre que C, Go ou Rust.
Avec mon binôme, on a choisi Rust. J’en entendais beaucoup parler, il avait été inclus dans les coulisses de Linux, tout le monde hâtait les autres de l’utiliser, d’autres déconseillaient de sauter dessus, je voulais voir ce que ça valait et à quoi ça ressemblait.
Et en commençant à développer avec, ça m’a tout de suite intéressé.
- “Comment ça il emprunte ma variable?”
- “J’ai jamais vu un typage aussi fort”
- “Tu as mis une étoile, mais c’est une esperluette qu’il faut”
- “Il met beaucoup, beaucoup de warnings quand même…”
Ahh, les joies confuses de débuter dans un langage.
Le terrain était bien préparé pour que la conférence attise ma curiosité. Alors je me suis inscris, et le 23 Septembre, j’attendais patiemment sur ma chaise en plastique que Benjamin Coenen vienne se poster devant un écran qui disait :
“Rust : sûr et concurrent. Mais comment fait-il ?”
Monsieur Coenen, il m’a pris par surprise. Il a travaillé sur rust-analyzer, l’extension qui permet de supporter Rust sur VSCode. Littéralement, l’outil qui m’a sauvé la vie pour comprendre ce que je faisais jusque là dans mon projet. Et c’est pas tout ! Il a travaillé chez OVHcloud, Snapchat, Cosmian, et il travaille actuellement chez ApolloGraphQL sur les outils de développement en Rust.
Ça fait 7 ans qu’il développe en Rust. Rien à dire, je suis tombé sur la bonne personne pour expliquer ce que je vais résumer juste en dessous.
Rust : les origines
Rust, à l’origine, c’est un projet personnel d’un employé de Mozilla qui a pointé le bout de son nez en 2010. Le but de ce projet, c’était de contourner les bugs de sécurité de mémoire causés par C et C++. En cherchant à régler ce problème, boum, le mec a créé un nouveau langage.
Rust, c’est très performant au runtime, long à la compilation, et - roulement de tambour - il n’a pas de garbage collector. Si, si, ça m’a fait bizarre aussi.
Ça m’a perturbé, mais l’explication m’a au passage aussi donné une réponse à “pourquoi il emprunte ma variable”.
C’est ma variable
En Rust, la valeur dans la pile pointe vers l’adresse mémoire dans le tas dont la valeur est celle de la variable utilisée. Le rôle du Borrow Checker (le truc qui vérifie si ma variable est “empruntable”), c’est de vérifier et empêcher tout problème de memory safety en s’assurant qu’il n’y a qu’un seul propriétaire pour chaque donnée.
Autrement dit, une variable est propriétaire d’une donnée, et il ne peut y en avoir qu’une seule.
Il est donc très important de préciser si une variable est immuable ou non, et le cas échéant, dans quelle mesure. Il y a 3 règles pour un type T :
T: variable propriétaire&T: partage de la donnée&mut T: prêt mutable à une entité
Si mut n’est pas indiqué, aucune modification de la valeur ne sera possible. Elle restera identique tout le long de son lifetime.
Le mot-clé &self représente une référence immuable à l’instance courante. Ça permet d’appeler des méthodes sans transférer la propriété de l’objet. Si une méthode a besoin de modifier l’objet, elle prendra un &mut self à la place.
Quelques mots sur les traits
Rust permet également d’implémenter des interfaces (appelées traits) sur des types existants. Par exemple, on peut ajouter une méthode personnalisée au type String en définissant un trait et en l’implémentant pour String. Ça encourage la composition plutôt que l’héritage.
Les traits en Rust sont comparables aux interfaces dans d’autres langages : ils définissent un ensemble de méthodes qu’un type doit implémenter.
Par exemple, le trait Drop permet de spécifier un comportement à exécuter lorsque la variable sort de son scope. En d’autres termes, c’est une manière sécurisée de nettoyer les ressources avant que la donnée soit supprimée, un peu comme les destructeurs en C++.
Grâce à ce mécanisme, Rust évite les memory leaks et anticipe les morts des variables.
Smart pointers : copieur de C++
Rust emprunte le concept de smart pointers au C++, mais en l’intégrant de manière beaucoup plus sûre. L’idée est d’envelopper une donnée dans un type qui gère la mémoire et la sécurité d’accès.
Contrairement à beaucoup d’autres langages, Rust n’a pas de null. Eh oui. Ça m’a fait m’arracher le peu de cheveux que j’ai plusieurs fois.
À la place, il propose le type Option<T>, qui force à gérer explicitement le cas où une donnée peut être absente. Le langage lui-même nous reprend sur nos mauvaises pratiques!
Le type Box<T> permet de stocker une donnée sur le tas au lieu de la pile. C’est utile quand on ne connaît pas la taille de l’objet à la compilation, ou lorsqu’on veut transférer la propriété d’un objet volumineux sans le copier.
Rc<T> (pour Reference Counted) est un smart pointer qui permet de partager une donnée immuable entre plusieurs propriétaires.
Chaque fois qu’on clone un Rc, le compteur de références interne est incrémenté. Quand toutes les références sont libérées, la mémoire est automatiquement désallouée. Ce mécanisme reste compatible avec le borrow checker, et garantit qu’aucune violation de sécurité mémoire ne se produise.
En revanche, Rc n’est pas thread-safe : il ne doit être utilisé que dans un seul thread. Pour le partage entre threads, Rust propose Arc<T> (Atomic Reference Counted).
Mais ça, ce sera une histoire pour plus tard.
Conclusion et ressources
Evidemment, ce pauvre petit article ne sera pas suffisant pour retranscrire tout ce qui a été échangé pendant cette soirée. Je n’ai même pas abordé tout le contenu de la présentation, et absolument pas les questions/réponses qui ont suivi. Mais c’était un évènement et une découverte qui m’a vraiment éclairé, et j’ai adoré pouvoir partager ce moment avec une treintaine d’autres passionnés.
Le lendemain, j’ai pu fièrement expliquer à mon binôme comment on allait partager nos variables, et ça, c’est quelque chose.
Si vous souhaitez voir le replay de la conférence, c’est juste ici
Pour accèder au LinkedIn de Benjamin Coenen, c’est ici
Et pour voir les évènements à venir du Ch’ti Jug, vous l’aurez deviné, c’est… ici
Je remercie du fond du coeur le Ch’ti Jug pour avoir organisé cet évènement, et Benjamin Coenen pour son expertise et sa patience face à tous les regards confus qu’il a dû voir dans la salle, et à qui il a pris le temps d’expliquer au maximum ce qu’il racontait.
A bientôt pour un prochain Ch’ti Jug !!