Comment endiguer la dette technique avec Rust ?

La dette technique peut être un obstacle important dans le développement logiciel, et nombreuses sont les entreprises qui y sont confrontées. Même si cela ne permettra pas de résoudre en un claquement de doigts leurs soucis, Rust se positionne comme un langage sérieux et fiable pour réécrire certaines parties, voire la totalité, des applications endiguées dans une dette technique. Voyons quelques stratégies nous pourrions appliquer pour réduire ou tout simplement éviter la dette technique avec Rust. Je vous donnerai également mon retour d’expérience sur ces différentes stratégies.

Qu’est-ce que la dette technique ?

Court rappel de cette notion, c’est Ward Cunnigham qui a introduit, en 1992, l’expression « dette technique » dans le développement web. Cet informaticien de renom est également à l’origine des concepts de wiki et un des co-auteurs du premier manifeste l’agilité. 

La dette technique est comme une dette financière. Si elle n’est pas remboursée régulièrement, elle peut devenir un fardeau écrasant qui freine le développement futur du projet. – Ward Cunnigham

La dette technique, dans un projet de développement, représente donc l’accumulation de compromis ou de solutions rapides adoptées pour gagner du temps ou respecter des délais, mais qui, à long terme, peuvent ralentir le développement futur. Cela peut inclure du code mal structuré, une absence de tests, ou encore l’utilisation de technologies obsolètes. Bien que cela permette d’avancer rapidement dans un premier temps, la dette technique doit être « remboursée » en améliorant ou réécrivant ces parties du code. Si elle n’est pas traitée, elle peut rendre le projet plus complexe à maintenir, à faire évoluer, et augmenter les risques de bugs.

Maîtriser la dette technique avec Rust : une sécurité mémoire robuste et un typage avancé 🦀

Le langage de programmation Rust garantit l’absence de certaines erreurs courantes liées à la gestion de la mémoire comme les pointeurs nuls ou les fuites de mémoire. En utilisant Rust, on peut réduire le risque d’erreurs graves qui sont souvent sources de dette technique.

Le typage de Rust est puissant, il permet de capturer les erreurs dés la compilation plutôt qu’à l’exécution. Cela aide à éliminer de nombreux bugs potentiels, avant qu’ils ne deviennent des problèmes de dette technique.

Suite à mes différentes expériences en Rust, j’ai pu me rendre compte du confort et de la sérénité que Rust pouvait apporter. En effet, lorsque l’on produit du code en Rust, et qu’il se compile sans erreur, on a une bonne garantie que le programme va s’exécuter comme prévu et sans bugs inattendus. Cette confiance est d’autant plus décuplée lorsque l’on livre notre programe dans un environnement conteneurisé. On a aussi la satisfaction d’avoir un programme performant et donc peu consommateur de ressources, ce qui permet de faire des économies côté serveur, tout en délivrant une expérience satisfaisante aux utilisateurs.

Entre autres, on peut parler bien sûr du système d’ownership de Rust, pour lequel vous trouverez plus d’informations dans ce (très bon) article que j’ai rédigé 😊. Mais il y a deux autres concepts qui me viennent à l’esprit :
1. La gestion des erreurs en Rust : entre autres, l’utilisation du type Result permet de gérer les erreurs de manière explicite et sécurisée, évitant les fuites de mémoire ou les pointeurs nuls qui pourraient résulter d’une gestion incorrecte des erreurs.

2. Les structures de contrôle comme match qui permettent de s’assurer qu’aucune condition potentielle n’a pu être oubliée. Qui n’a pas déjà utilisé des if / else if en oubliant de traiter une des conditions du programme ? Rust empêchera de compiler le programme si cela arrive.

Une gestion facilité des concurrences et des threads

Rust facilite la gestion des threads et de la concurrence en prônant la sécurité et en évitant les courses aux données (ou data races) et autres problèmes typiques des systèmes multithreadés. Cela contribue à une base de code plus stable et moins sujette aux erreurs complexes.

Pour réduire la dette technique avec Rust, on utilise régulièrement deux types pour assurer la concurrence :

• • Arc qui permet de partager une valeur entre les threads de manière sécurisée

• • Mutex qui permet d’éviter les data races en gérant l’accès concurrentiel. Les Mutex peuvent être verrouillés pour garantir un accès exclusif.

Librairies sûres et performantes avec Rust

La communauté Rust développe des bibliothèques sûres et performantes qui peuvent être utilisées pour éviter de réinventer la roue et réduire ainsi le risque de bugs introduits par du code non testé ou non sécurisé.

Pour cela, rien de mieux que des exemples concrets de projets et librairies en vogue. On en a répertorié quelques uns dans deux articles : Rust est partout et 5 projets Rust prometteurs en 2024

Contrôler la dette technique avec Rust : une vision à long terme

Rust encourage les bonnes pratiques de programmation et une architecture logicielle modulaire et propre. Cela facilite la maintenance à long terme du code, et permet donc de réduire l’accumulation de dette technique, due à une complexité bien trop élevée et un code mal structuré.

Pour cela, André de chez O’Clock nous a préparé une chouette vidéo qui permet de mieux comprendre la structuration de projet avec Rust !
Un article vient en complément de cette vidéo : Comment structurer un projet Rust ?

En bref, Rust est un super langage pour faire évoluer la stack technique d’une entreprise. Il permet de se prémunir de pleins de problèmes et permet donc de mieux dormir la nuit. Mangez du Rust, c’est bon pour votre santé ! Si avec tout ça vous n’êtes pas convaincus des bénéfices d’ajouter Rust à votre boîte à outils de développeur, c’est que vous n’aimez vraiment pas les crustacés… 🦀💻