![\"\"](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2024\/09\/image-17.png\")
<\/figure>\nVous remarquerez que Rust est le seul langage ayant obtenu un r\u00e9sultat \u00e0 deux chiffres dans la colonne \u00ab\u00a0Likely to adopt\u00a0\u00bb\u00a0!<\/p>\n
L’engouement des d\u00e9veloppeurs pour Rust est \u00e9galement significatif. Comment puis-je le savoir ? Les r\u00e9sultats de l’enqu\u00eate sur les d\u00e9veloppeurs de StackOverflow en attestent :<\/p>\n
- \n
- Rust continue d’\u00eatre le langage qui suscite le plus d’int\u00e9r\u00eat<\/a> dans la communaut\u00e9 de d\u00e9veloppeurs, et ce depuis de nombreuses ann\u00e9es cons\u00e9cutives (huit ans ? neuf ans ? On ne sait m\u00eame plus exactement\u00a0!).<\/li>\n
- Les d\u00e9veloppeurs qui travaillent d\u00e9j\u00e0 avec Rust n’envisagent aucunement de passer<\/a> \u00e0 un autre langage de programmation.<\/li>\n<\/ul>\n
En tant que participant r\u00e9gulier \u00e0 des conf\u00e9rences pour les d\u00e9veloppeurs Rust, je peux \u00e9galement t\u00e9moigner de cet engouement pour Rust. Les utilisateurs de Rust constituent l’une des communaut\u00e9s de d\u00e9veloppeurs les plus dynamiques et conviviales.<\/p>\n
D’un autre c\u00f4t\u00e9, l’enqu\u00eate de StackOverflow rapporte<\/a> une baisse du salaire annuel m\u00e9dian au cours des deux derni\u00e8res ann\u00e9es, mais cette tendance s’observe \u00e9galement pour d’autres langages de programmation populaires. Malgr\u00e9 son adoption croissante par de grandes entreprises et des entreprise de taille moyenne du secteur informatique, nombreuses petites entreprises n’utilisent pas encore Rust, il pourrait donc y avoir davantage d’offres d’emploi pour des d\u00e9veloppeurs Rust \u00e0 l’avenir (je vous invite \u00e0 consulter cette passionnante discussion<\/a> pour plus d’informations sur ce sujet).<\/p>\n
Si on examine plus en d\u00e9tail les fonctionnalit\u00e9s et l’\u00e9cosyst\u00e8me du langage, on comprend imm\u00e9diatement les chiffres mentionn\u00e9s plus haut. Rust a \u00e9t\u00e9 con\u00e7u pour offrir \u00e0 la fois davantage de s\u00e9curit\u00e9 en mati\u00e8re de m\u00e9moire et de meilleures performances. Les choix uniques qu’ont fait les concepteurs du langage favorisent la diminution des erreurs d’acc\u00e8s \u00e0 la m\u00e9moire dans le code, ce qui r\u00e9duit les risques de failles de s\u00e9curit\u00e9 sans que les performances n’en p\u00e2tissent. Alors, quel est donc le \u00ab prix \u00e0 payer \u00bb pour cela ? Eh bien, c’est tout le temps que vous devez passer \u00e0 convaincre le compilateur Rust que votre code est vraiment s\u00fbr. Une fois que le compilateur est d’accord avec vous, vous \u00eates tranquille. Ensemble, la s\u00e9curit\u00e9 de la m\u00e9moire et les performances du langage permettent d’offrir une exp\u00e9rience beaucoup plus fluide aux utilisateurs de solutions logicielles (c’est-\u00e0-dire quasiment tout le monde de nos jours). La biblioth\u00e8que standard de Rust, d’autres biblioth\u00e8ques essentielles et ensembles d’outils am\u00e9liorent \u00e9galement l’exp\u00e9rience de d\u00e9veloppement. Par exemple, d\u00e9velopper des applications concurrentes hautes performances en Rust n’est pas difficile, car l’\u00e9cosyst\u00e8me est mature et bien \u00e9quip\u00e9 pour prendre en charge de telles t\u00e2ches.<\/p>\n
Les d\u00e9veloppeurs appr\u00e9cient \u00e9galement le grand nombre de secteurs d’activit\u00e9 et de domaines technologiques dans lesquels Rust est applicable. L’enqu\u00eate annuelle sur Rust<\/a> la plus r\u00e9cente a notamment identifi\u00e9 les domaines suivants\u00a0:<\/p>\n
- \n
- Applications c\u00f4t\u00e9 serveur et autres applications backend.<\/li>\n
- Applications, services et infrastructures de cloud computing.<\/li>\n
- Syst\u00e8mes distribu\u00e9s.<\/li>\n
- R\u00e9seaux informatiques.<\/li>\n
- S\u00e9curit\u00e9 informatique.<\/li>\n
- D\u00e9veloppement embarqu\u00e9.<\/li>\n
- D\u00e9veloppement de jeux.<\/li>\n
- Frontends web (y compris WebAssembly).<\/li>\n
- Et bien d’autres.<\/li>\n<\/ul>\n
Rust n’est \u00e9videmment pas le seul langage de programmation utilis\u00e9 dans ces domaines. Il a des concurrents dans chacun d’eux. Il est souvent compar\u00e9 \u00e0 C++ ou \u00e0 Go, car ils ont de nombreux points communs, mais ils diff\u00e8rent sur plusieurs points, notamment en ce qui concerne les garanties en mati\u00e8re de s\u00e9curit\u00e9 de la m\u00e9moire, les performances, la disponibilit\u00e9 des outils et des biblioth\u00e8ques, la simplicit\u00e9 du langage et les secteurs d’activit\u00e9s dans lesquels ils sont le plus utilis\u00e9s. Rust n’obtient pas les meilleurs r\u00e9sultats \u00e0 tous les niveaux, mais offre des performances aussi bonnes que C++ et se distingue par sa capacit\u00e9 \u00e0 permettre d\u2019\u00e9viter les pi\u00e8ges li\u00e9s \u00e0 l\u2019acc\u00e8s \u00e0 la m\u00e9moire facilement et de cr\u00e9er des applications sans erreurs.<\/p>\n
Comprendre les concepts fondamentaux de Rust<\/h2>\n
Prenons de la hauteur pour avoir une vue d’ensemble de Rust et de ses fonctionnalit\u00e9s. Rust n’est ni un langage de programmation orient\u00e9 objet, ni un langage de programmation fonctionnel. Il ne comporte pas de classes et ne prend pas directement en charge les mod\u00e8les orient\u00e9s objet. Il peut op\u00e9rer avec des fonctions comme valeurs de premi\u00e8re classe, mais cette capacit\u00e9 est limit\u00e9e par rapport aux langages fonctionnels \u00e0 part enti\u00e8re (comme Haskell ou OCaml).<\/p>\n
\u00c9crire du code avec des fonctions, des valeurs et des types<\/h3>\n
Les programmes en Rust sont structur\u00e9s comme des collections de fonctions combin\u00e9es en modules. Les fonctions manipulent les valeurs. Les valeurs sont typ\u00e9es de mani\u00e8re statique, ce qui signifie que chaque valeur ou expression doit avoir un type attribu\u00e9 au moment de la compilation. Rust fournit \u00e0 la fois des types primitifs et compos\u00e9s (tableaux et structures), et sa biblioth\u00e8que standard fournit de nombreux types suppl\u00e9mentaires pour les collections de valeurs. Il prend en charge les types g\u00e9n\u00e9riques, ce qui permet d’\u00e9viter d’avoir \u00e0 mentionner des types sp\u00e9cifiques et de fournir des d\u00e9finitions plus g\u00e9n\u00e9rales. Rust fournit \u00e9galement des traits comme collections de m\u00e9thodes (c’est-\u00e0-dire de fonctions) qui peuvent \u00eatre impl\u00e9ment\u00e9s pour des types sp\u00e9cifiques. Les traits permettent \u00e0 Rust d’atteindre les m\u00eames niveaux d’abstraction logicielle que les langages orient\u00e9s objet qui prennent en charge l’h\u00e9ritage et le polymorphisme.<\/p>\n
Gestion de la m\u00e9moire<\/h3>\n
L’approche de Rust en mati\u00e8re de gestion de la m\u00e9moire repose sur le principe suivant\u00a0: le compilateur Rust doit savoir pr\u00e9cis\u00e9ment \u00e0 quels emplacements la m\u00e9moire est allou\u00e9e dans le code, comment on y acc\u00e8de, et l\u00e0 o\u00f9 elle n’est plus n\u00e9cessaire<\/strong>. Ces informations permettent de contr\u00f4ler l’acc\u00e8s \u00e0 la m\u00e9moire et de lib\u00e9rer automatiquement la m\u00e9moire allou\u00e9e en ins\u00e9rant les instructions correspondantes directement dans le code g\u00e9n\u00e9r\u00e9, ce qui contribue \u00e0 \u00e9viter de nombreux pi\u00e8ges courants auxquels on est expos\u00e9 avec d’autres langages. Cette approche diff\u00e8re de la gestion automatique de la m\u00e9moire (comme en JavaScript, Python, Java ou C#), dans laquelle les fragments de m\u00e9moire qui ne sont plus n\u00e9cessaires sont d\u00e9tect\u00e9s au moment de l’ex\u00e9cution et supprim\u00e9s par le ramasse-miettes. Rust \u00e9conomise ainsi le temps n\u00e9cessaire \u00e0 l’ex\u00e9cution des algorithmes correspondants au moment de l’ex\u00e9cution et atteint un double objectif de s\u00e9curit\u00e9 de la m\u00e9moire et de performance.<\/p>\n
Pour pouvoir inf\u00e9rer des connaissances sur l’acc\u00e8s \u00e0 la m\u00e9moire, Rust fixe des limites concernant ce qui peut \u00eatre fait avec la m\u00e9moire et d\u00e9finit des r\u00e8gles strictes pour garantir l’exactitude\u00a0:<\/p>\n
- \n
- Chaque fragment de m\u00e9moire doit appartenir \u00e0 une seule variable : le mod\u00e8le de propri\u00e9t\u00e9<\/em> de Rust repose sur ce point.<\/li>\n
- La mutation d’un fragment de m\u00e9moire n\u00e9cessite un acc\u00e8s exclusif (par opposition \u00e0 une simple lecture de la m\u00e9moire).<\/li>\n
- Rust permet de cr\u00e9er des r\u00e9f\u00e9rences mutables et immuables \u00e0 des fragments de m\u00e9moire (en les empruntant) mais utilise un v\u00e9rificateur d’emprunt<\/em> pour garantir l’exactitude (par exemple, en interdisant plus d’une r\u00e9f\u00e9rence mutable).<\/li>\n
- Le compilateur Rust calcule et v\u00e9rifie les dur\u00e9es de vie<\/em> de chaque variable dans un programme, de l’emplacement o\u00f9 elle est cr\u00e9\u00e9e \u00e0 celui o\u00f9 elle est supprim\u00e9e (o\u00f9 elle devient inaccessible).<\/li>\n<\/ul>\n
Les exigences du compilateur peuvent \u00eatre per\u00e7ues comme trop strictes. C’est une cause de frustration courante, en particulier lors de l’apprentissage du langage : le compilateur Rust peut refuser un fragment de code qui est logiquement correct.<\/p>\n
Pour faciliter la compr\u00e9hension de ces concepts, examinons l’\u00e9quivalent Rust du programme Python suivant\u00a0:<\/p>\n
def print_list(numbers):\n for number in numbers:\n print(str(number) + \" \", end=\"\")\n print()\n\n\ndef add_one(numbers):\n numbers.append(1)\n\n\ndef main():\n numbers = [1, 1, 1]\n print_list(numbers)\n add_one(numbers)\n print_list(numbers)\n\n\nif __name__ == '__main__':\n main()<\/pre>\n
Nous avons donc un fragment de m\u00e9moire (la liste Python) avec trois \u00e9l\u00e9ments. Nous l’imprimons, ajoutons un \u00e9l\u00e9ment suppl\u00e9mentaire, et l’imprimons \u00e0 nouveau. Nous ne mentionnons jamais aucun type ici. Python n’a besoin d’aucun signe de gestion de la m\u00e9moire dans le programme, m\u00eame si la m\u00e9moire doit \u00eatre allou\u00e9e et lib\u00e9r\u00e9e \u00e0 un moment donn\u00e9. De plus, nous transmettons la liste
numbers<\/code> facilement, sans avoir \u00e0 penser au contr\u00f4le d’acc\u00e8s \u00e0 la m\u00e9moire.\u00a0<\/p>\nLe m\u00eame code en Rust diff\u00e8re non seulement par sa syntaxe, mais aussi dans son approche des types et de la gestion de la m\u00e9moire\u00a0:<\/p>\n
\/\/ Here we take a vector by reference (&).\n\/\/ We are not allowed to mutate elements.\n\/\/ We don't take ownership; we just borrow.\nfn print_vec(numbers: &Vec) {\n for number in numbers {\n print!(\"{} \", number);\n }\n println!()\n}\n\n\n\/\/ Here we take a vector by mutable reference (&mut).\n\/\/ We are now allowed to mutate elements and the vector itself.\n\/\/ We still don't take ownership; we just borrow.\nfn add_one(numbers: &mut Vec) {\n numbers.push(1)\n}\n\n\nfn main() {\n let mut numbers = vec![1,1,1];\n \/\/ We pass a reference\n print_vec(&numbers);\n \/\/ We pass a mutable reference\n add_one(&mut numbers);\n \/\/ We pass a reference again\n print_vec(&numbers);\n}<\/pre>\nJe vous invite \u00e0 explorer ces deux fragments de code et \u00e0 trouver par vous-m\u00eame les similitudes et les diff\u00e9rences entre eux. M\u00eame sans comprendre Rust, vous pouvez vous en faire une id\u00e9e g\u00e9n\u00e9rale simplement en examinant ce code.<\/p>\n
Malgr\u00e9 le passage des r\u00e9f\u00e9rences en param\u00e8tres, la variable numbers reste propri\u00e9taire de la m\u00e9moire allou\u00e9e. Rust utilise par d\u00e9faut un acc\u00e8s m\u00e9moire en lecture seule et requiert une sp\u00e9cification explicite pour l’acc\u00e8s en \u00e9criture. Rust garantit \u00e9galement que la m\u00e9moire soit lib\u00e9r\u00e9e apr\u00e8s la derni\u00e8re utilisation dans le deuxi\u00e8me appel \u00e0
print_vec<\/code>.\u00a0<\/p>\nVoici une variante de la fonction add_one qui prend possession d’un vecteur et rend l’ensemble du programme incorrect\u00a0:<\/p>\n
fn add_one_incorrect(mut numbers: Vec) {\n\u00a0\u00a0\u00a0numbers.push(1)\n}<\/pre>\nQuel est le probl\u00e8me ? Eh bien, apr\u00e8s avoir appel\u00e9 la fonction
add_one_incorrect<\/code>, la variable numbers ne poss\u00e8de plus la m\u00e9moire\u00a0; sa dur\u00e9e de vie est termin\u00e9e, nous ne pouvons donc rien imprimer\u00a0! La capture d’\u00e9cran ci-dessous montre quel est le probl\u00e8me\u00a0:<\/p>\n![\"\"](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2024\/09\/Screenshot-2024-09-18-at-18.19.01.png\")
<\/figure>\nAvant l’introduction de la version incorrecte, le v\u00e9rificateur d’emprunt de Rust pouvait garantir que le passage des r\u00e9f\u00e9rences ne posait aucun probl\u00e8me. Apr\u00e8s l’introduction d’une erreur, cela n’est plus possible. Ici, le comportement du langage montre \u00e0 quel point l’acc\u00e8s \u00e0 la m\u00e9moire est strictement contr\u00f4l\u00e9.<\/p>\n
Concurrence<\/h3>\n
La concurrence est la capacit\u00e9 d’un syst\u00e8me \u00e0 ex\u00e9cuter plusieurs t\u00e2ches ou processus simultan\u00e9ment ou pendant des p\u00e9riodes qui se chevauchent pour am\u00e9liorer l’efficacit\u00e9 et les performances. Cela peut impliquer une ex\u00e9cution parall\u00e8le sur de multiples processeurs ou une ex\u00e9cution entrelac\u00e9e sur un seul processeur, ce qui permet \u00e0 un syst\u00e8me de traiter plusieurs op\u00e9rations simultan\u00e9ment et de g\u00e9rer plusieurs t\u00e2ches plus efficacement.<\/p>\n
Les Rustac\u00e9s disent g\u00e9n\u00e9ralement de la concurrence de Rust qu’elle est impressionnante. Plusieurs facteurs expliquent cette perception :<\/p>\n
- \n
- Le mod\u00e8le de propri\u00e9t\u00e9 ajoute plus de contr\u00f4le sur le partage des donn\u00e9es entre les threads concurrents.<\/li>\n
- L’adoption de structures de donn\u00e9es immuables simplifie l’impl\u00e9mentation d’algorithmes concurrents et contribue \u00e0 la s\u00e9curit\u00e9 des threads.<\/li>\n
- La transmission des messages via les canaux adopt\u00e9s en Rust r\u00e9duit consid\u00e9rablement les complexit\u00e9s li\u00e9es \u00e0 la concurrence d’\u00e9tat partag\u00e9.<\/li>\n
- L’approche de Rust en mati\u00e8re de dur\u00e9e de vie et de gestion de la m\u00e9moire rend g\u00e9n\u00e9ralement le code qui utilise des primitives de concurrence telles que des verrous, des s\u00e9maphores ou des barri\u00e8res, plus concis et plus s\u00fbr.<\/li>\n
- Dans de nombreux cas, l’approche de Rust en mati\u00e8re de programmation asynchrone \u00e9vite d’utiliser des sch\u00e9mas de concurrence complexes et permet d’\u00e9crire du code concis et clair.<\/li>\n<\/ul>\n
Bien que la concurrence ne soit pas la premi\u00e8re chose que les d\u00e9butants apprennent lorsqu’ils abordent Rust, elle reste plus facile \u00e0 comprendre que dans de nombreux autres langages de programmation. Plus important encore, Rust vous aide \u00e0 \u00e9crire un code concurrent moins propice aux erreurs.<\/p>\n
Premiers pas avec Rust<\/h2>\n
Il suffit d’installer deux choses sur votre ordinateur pour d\u00e9marrer avec Rust\u00a0:<\/p>\n
- \n
- La cha\u00eene d’outils Rust\u00a0: une collection d’outils qui comprend le compilateur Rust et d’autres utilitaires.<\/li>\n
- Un \u00e9diteur de code ou un IDE (environnement de d\u00e9veloppement int\u00e9gr\u00e9).\u00a0<\/li>\n<\/ol>\n
La premi\u00e8re \u00e9tape est simple\u00a0: allez sur rustup.rs<\/a> et ex\u00e9cutez la commande qu’ils sugg\u00e8rent, ou t\u00e9l\u00e9chargez un installateur, en fonction de votre syst\u00e8me d’exploitation.<\/p>\n
La deuxi\u00e8me \u00e9tape n\u00e9cessite de faire un choix. Vous pouvez utiliser un \u00e9diteur de code configur\u00e9 pour prendre en charge Rust (par exemple, Visual Studio Code prend en charge Rust mais requiert un peu de configuration) ou opter pour un IDE Rust d\u00e9di\u00e9 (tel que RustRover<\/a>, l’IDE de JetBrains gratuit pour une utilisation \u00e0 des fins d’apprentissage).<\/p>\n
\nObtenez RustRover gratuitement<\/a><\/div>\n<\/div>\nSi vous choisissez RustRover, vous n’avez rien \u00e0 configurer. Vous pouvez le lancer, cr\u00e9er un nouveau projet (\u00e0 l’aide du bouton New Project<\/em> sur l’\u00e9cran d’accueil), et ex\u00e9cuter le programme Hello, world!<\/em> g\u00e9n\u00e9r\u00e9 par d\u00e9faut (utilisez l’ic\u00f4ne triangulaire verte dans la goutti\u00e8re pour ex\u00e9cuter la fonction main)\u00a0:<\/p>\n
![\"\"](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2024\/09\/image-18.png\")
<\/figure>\nSi vous rencontrez un probl\u00e8me, consultez le guide de d\u00e9marrage rapide de RustRover (Quick Start Guide<\/a>).\u00a0<\/p>\n
\u00c0 moins qu’il ne s’agisse d’une t\u00e2che vraiment simple, vous devrez ajouter des d\u00e9pendances externes. Les projets Rust s’appuient sur Cargo, un gestionnaire de paquets. En Rust, les paquets s’appellent des crates<\/strong>. Les d\u00e9pendances sont sp\u00e9cifi\u00e9es dans le fichier
Cargo.toml<\/code>, par exemple\u00a0:<\/p>\n[package]\nname = \"hello\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n[dependencies]\nchrono = \"0.4.38\"<\/pre>\n
Apr\u00e8s avoir ajout\u00e9 la crate
chrono<\/code> \u00e0 nos d\u00e9pendances, nous pouvons utiliser les fonctionnalit\u00e9s qu’elle fournit dans notre code, par exemple\u00a0:<\/p>\nuse chrono::{DateTime, Local};\n\nfn main() {\n println!(\"Hello, world!\");\n let local: DateTime = Local::now();\n println!(\"Today is {}\", local.format(\"%A\"));\n}<\/pre>\nDans ce programme, nous obtenons la date et l’heure (locales) actuelles, les formatons comme un jour de la semaine, puis affichons le r\u00e9sultat. L’ex\u00e9cution de ce programme donne par exemple\u00a0:<\/p>\n
Hello, world!\nToday is Thursday<\/pre>\n
L’apprentissage de la syntaxe de base, des types de donn\u00e9es et des structures de contr\u00f4le (conditions if, boucles, etc.) en Rust est un processus parall\u00e8le \u00e0 l’apprentissage des crates disponibles et de ce qu’elles fournissent. Une fois que vous pourrez ex\u00e9cuter des programmes Rust, vous serez pr\u00eat \u00e0 travailler avec des d\u00e9pendances externes. Parlons des ressources qui simplifient l’apprentissage de Rust.<\/p>\n
Parcours d’apprentissage et ressources<\/h2>\n
Si vous avez d\u00e9j\u00e0 appris une langue \u00e9trang\u00e8re, vous savez que diverses comp\u00e9tences sont requises, comme la compr\u00e9hension \u00e9crite, l’expression \u00e9crite, la compr\u00e9hension orale et l’expression orale. Plusieurs types d’activit\u00e9s permettent de d\u00e9velopper ces comp\u00e9tences. Les enseignants vous encouragent toujours \u00e0 lire des textes, \u00e0 regarder des vid\u00e9os, \u00e0 \u00e9couter des podcasts, \u00e0 parler autant que possible, \u00e0 publier sur les r\u00e9seaux sociaux, etc. C’est la m\u00eame chose pour apprendre un langage de programmation. Pour apprendre comment coder en Rust (ou avec tout autre langage de programmation), vous devrez :<\/p>\n
- \n
- Lire des livres, de la documentation, des articles de blog, les annonces de nouvelles versions et des discussions sur les r\u00e9seaux sociaux (ce qui est essentiel pour rester inform\u00e9 et conna\u00eetre le contexte actuel).<\/li>\n
- Regarder des vid\u00e9os de blogueurs sp\u00e9cialis\u00e9s.<\/li>\n
- Examiner des exemples de code (ce qui n\u00e9cessite de les lire et de les modifier\u00a0!).<\/li>\n
- \u00c9crire du code pour vous exercer.<\/li>\n
- Suivre des tutoriels pratiques.<\/li>\n
- D\u00e9velopper des projets simples \u00e0 partir de z\u00e9ro (c’est extr\u00eamement important : l’apprentissage bas\u00e9 sur la r\u00e9alisation de projets est toujours utile pour d\u00e9velopper des comp\u00e9tences en programmation de fa\u00e7on ind\u00e9pendante).<\/li>\n
- Peut-\u00eatre m\u00eame contribuer \u00e0 des projets open source (il y a toujours quelque chose \u00e0 faire, m\u00eame pour les d\u00e9butants, il suffit de demander !).<\/li>\n<\/ul>\n
Il est important de maintenir un \u00e9quilibre entre le temps pass\u00e9 \u00e0 lire des contenus et \u00e9crire du code. Il est impossible de ma\u00eetriser un langage de programmation sans le pratiquer r\u00e9ellement en \u00e9crivant du code. Dans le m\u00eame temps, il est essentiel de consulter des livres ou autres documents pour parvenir \u00e0 une compr\u00e9hension approfondie des d\u00e9tails sp\u00e9cifiques au langage. Tout cas complexe pourrait devenir extr\u00eamement difficile \u00e0 r\u00e9soudre sans aide ext\u00e9rieure (ce qui peut vous ralentir dans votre parcours pour devenir un d\u00e9veloppeur professionnel).<\/p>\n
Lorsque vous \u00e9crivez du code, il est important de reproduire des exercices, mais aussi de suivre vos propres id\u00e9es (ou de vous inspirer d’autres id\u00e9es) pour d\u00e9velopper des applications simples. Assurez-vous que vos exercices ne se limitent pas \u00e0 la compr\u00e9hension d’algorithmes, mais enseignent \u00e9galement les fonctionnalit\u00e9s du langage et les fonctions de la biblioth\u00e8que. En d\u00e9veloppant des applications simples, vous apprendrez \u00e0 choisir la fonctionnalit\u00e9 du langage ou la biblioth\u00e8que qui r\u00e9pond le mieux \u00e0 votre objectif. C’est une comp\u00e9tence essentielle en soi.<\/p>\n
Ainsi, la cl\u00e9 d’un apprentissage r\u00e9ussi est de combiner toutes ces approches. Je connais une s\u00e9rie de ressources qui peuvent vous y aider.<\/p>\n
Livres sur Rust<\/h3>\n
Il existe beaucoup de bons livres pour apprendre Rust\u00a0:<\/p>\n
\n![\"\"](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2024\/09\/image-19.png\")
<\/figure>\n<\/div>\n\n![\"\"](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2024\/09\/image-20.png\")
<\/figure>\n<\/div>\n- \n
- The Rust Programming Language<\/em><\/a> est un livre officiel sur le langage r\u00e9guli\u00e8rement actualis\u00e9, destin\u00e9 aux personnes qui apprennent Rust. Il est connu sous le nom de The Book<\/em> au sein de la communaut\u00e9. Je recommande \u00e9galement une autre version<\/a> de ce livre qui apporte plus d’interactivit\u00e9, avec des quiz, des visualisations et des exercices. Cette version a \u00e9t\u00e9 d\u00e9velopp\u00e9e par Will Crichton, Gavin Gray et Shriram Krishnamurthi, chercheurs \u00e0 l’Universit\u00e9 Brown. Il existe \u00e9galement une une interview<\/a> avec Will Crichton, dans laquelle il explique cette exp\u00e9rimentation pour am\u00e9liorer l’exp\u00e9rience des personnes apprenant Rust.<\/li>\n
- Rust in Action<\/em><\/a> par Tim McNamara (\u00e9galement connu sous le nom de timClicks<\/a>\u00a0; mon conseil est de le suivre partout).<\/li>\n
- Hands-on Rust<\/em><\/a> par Herbert Wolverson : le livre qui pla\u00eet particuli\u00e8rement \u00e0 ceux qui appr\u00e9cient l’apprentissage par projet (vous pouvez \u00e9galement trouver de nombreuses vid\u00e9os gratuites d’Herbert sur plusieurs concepts de Rust ; je ne saurais trop vous les recommander).<\/li>\n
- Rust for Rustaceans<\/em><\/a> par Jon Gjengset, un livre sur Rust pl\u00e9biscit\u00e9 par de nombreux membres de la communaut\u00e9.\u00a0\u00a0<\/li>\n
- Code Like a Pro in Rust<\/em><\/a> par Brenden Matthews.<\/li>\n
- Learn Rust in a Month of Lunches<\/em><\/a> par David MacLeod.<\/li>\n
- Apr\u00e8s quelques mois d’apprentissage de Rust, vous devriez jeter un \u0153il \u00e0 Rust Atomics and Locks<\/a><\/em>, par Mara Bos. C’est un chef-d’\u0153uvre en mati\u00e8re d’explication des concepts de bas niveau derri\u00e8re la concurrence en Rust.<\/li>\n<\/ul>\n
Tutoriels Rust<\/h3>\n
Pour ceux qui pr\u00e9f\u00e8rent une approche plus pratique de l’apprentissage, il existe \u00e9galement des tutoriels et des cours avec exercices\u00a0:<\/p>\n
- \n
- Comprehensive Rust<\/a> est un tutoriel Rust d\u00e9velopp\u00e9 en interne chez Google mais accessible \u00e0 tous. C’est la meilleure ressource pour ceux qui souhaitent apprendre rapidement tous les d\u00e9tails n\u00e9cessaires.<\/li>\n
- Rustlings<\/a> (et sa variation pour une exp\u00e9rience d’apprentissage dans l’IDE<\/a>, un cours<\/a> sur Rust de JetBrains Academy<\/a>).<\/li>\n
- 100 exercises to learn Rust<\/a> : un cours g\u00e9nial avec des exercices d\u00e9velopp\u00e9s par Luca Palmieri<\/a> (encore un autre Rustac\u00e9 \u00e0 suivre).<\/li>\n
- Eleftheria Batsou a pr\u00e9sent\u00e9 un bel ensemble d’id\u00e9es de projets simples<\/a> sur lesquels travailler tout en apprenant Rust.<\/li>\n<\/ul>\n
Rust sur YouTube<\/h3>\n
Pour les Rustac\u00e9s qui aiment apprendre sur YouTube, je recommande d’y suivre plusieurs cha\u00eenes :<\/p>\n
- \n
- Let’s Get Rusty<\/a> : je ne sais pas pourquoi, mais il est difficile d’arr\u00eater de regarder ces vid\u00e9os.<\/li>\n
- Jeremy Chone<\/a> est tr\u00e8s dou\u00e9 pour expliquer des concepts complexes.<\/li>\n
- Chris Biscardi<\/a> parle du d\u00e9veloppement de jeux en Rust avec le framework Bevy, entre autres. Cr\u00e9er un jeu est un excellent projet pour tout le monde\u00a0!<\/li>\n
- Jon Gjengset<\/a>\u00a0: pendant les deux premi\u00e8res ann\u00e9es de votre parcours avec Rust, il peut \u00eatre difficile de suivre ses streams techniques approfondis, mais je recommande de commencer \u00e0 les regarder assez t\u00f4t\u00a0!\u00a0<\/li>\n<\/ul>\n
La Communaut\u00e9 Rust<\/h3>\n
- \n
- La communaut\u00e9 Rust sur Reddit<\/a> m\u00e9rite d’\u00eatre suivie.<\/li>\n
- En tant que d\u00e9butant, vous pouvez poser vos questions sur le serveur Discord de la communaut\u00e9 Rust<\/a>.<\/li>\n
- This Week in Rust<\/a> est la ressource communautaire la plus importante pour lire les actualit\u00e9s concernant Rust. Je le lis chaque semaine sans exception.<\/li>\n<\/ul>\n
Bien entendu, de nombreuses autres ressources d’apprentissage sont disponibles, mais il est impossible de toutes les r\u00e9pertorier. La bonne nouvelle est que vous n’arr\u00eatez jamais d’apprendre Rust, car le langage \u00e9volue constamment.<\/p>\n
D\u00e9fis courants et comment les surmonter<\/h2>\n
Apprendre Rust peut \u00eatre complexe. Vous pouvez toutefois surmonter ces difficult\u00e9s et parvenir \u00e0 ma\u00eetriser le langage en adoptant la bonne strat\u00e9gie. Voici quelques conseils pour vous aider tout au long de votre parcours\u00a0:<\/p>\n
- \n
- Comprenez bien le mod\u00e8le de propri\u00e9t\u00e9.<\/strong> Le mod\u00e8le de propri\u00e9t\u00e9 de Rust, qui inclut des concepts tels que la propri\u00e9t\u00e9, l’emprunt et la dur\u00e9e de vie, est souvent l’aspect le plus difficile pour les d\u00e9butants. Commencez par de petits exemples et entra\u00eenez-vous fr\u00e9quemment. Cherchez surtout \u00e0 comprendre les raisons pour lesquelles Rust applique ces r\u00e8gles plut\u00f4t que de vous concentrer sur la mani\u00e8re de contourner les erreurs du compilateur.\u00a0<\/li>\n
- Prenez votre temps avec le v\u00e9rificateur d’emprunt.<\/strong> Le v\u00e9rificateur d’emprunt peut \u00eatre frustrant, car il est strict et peut conduire \u00e0 des erreurs de compilation d\u00e9routantes. Lorsque vous rencontrez des probl\u00e8mes avec le v\u00e9rificateur d’emprunt, prenez du recul et analysez ce que Rust essaie d’\u00e9viter. Exp\u00e9rimentez avec des approches telles que le r\u00e9f\u00e9rencement ou le clonage de donn\u00e9es (mais essayez de ne pas tout cloner\u00a0!). N’h\u00e9sitez pas \u00e0 demander de l’aide sur des forums comme Reddit ou le serveur Rust Community sur Discord. Il est vraiment utile de comprendre ce qu’est pr\u00e9cis\u00e9ment un v\u00e9rificateur d’emprunt. Consultez, par exemple, cette excellente explication<\/a> de Nell Shamrell-Harrington.<\/li>\n
- Tirez parti de la documentation de Rust.<\/strong> Rust est un langage relativement nouveau, donc certaines choses peuvent ne sont pas aussi facilement compr\u00e9hensibles qu’avec d’autres langages plus anciens. Utilisez la documentation Rust, qui est r\u00e9put\u00e9e pour \u00eatre compl\u00e8te et bien \u00e9crite. La communaut\u00e9 Rust contribue \u00e9galement \u00e0 d’excellentes ressources telles que le guide Rust by Example<\/a>.<\/li>\n
- Commencez par des projets simples. <\/strong>La complexit\u00e9 de Rust peut donner l’impression d’\u00eatre d\u00e9pass\u00e9 au d\u00e9but. Commencez par impl\u00e9menter des programmes basiques et passez progressivement \u00e0 des programmes plus complexes. Voici quelques exemples de projets simples\u00a0: la cr\u00e9ation d’un outil de ligne de commande avec clap<\/a>, l’\u00e9criture d’analyseurs de fichiers simples ou la cr\u00e9ation d’un serveur web de base \u00e0 l’aide d’un framework tel que Rocket<\/a>.<\/li>\n
- Familiarisez-vous avec votre \u00e9diteur de code ou votre IDE.<\/strong> \u00c9crire du code Rust manuellement peut entra\u00eener des erreurs. Les outils sont l\u00e0 pour vous aider pour la compl\u00e9tion, le linting et le formatage du code.<\/li>\n
- Rejoignez la communaut\u00e9 Rust.<\/strong> Cela vous \u00e9vitera de vous sentir isol\u00e9. Impliquez-vous en contribuant \u00e0 des projets open source, ou en participant \u00e0 des discussions et des forums. La communaut\u00e9 Rust est connue pour \u00eatre tr\u00e8s accueillante et aider les d\u00e9butants.<\/li>\n
- Apprenez de vos erreurs. <\/strong>Le compilateur de Rust est particuli\u00e8rement strict et vous pouvez avoir l’impression de batailler avec lui en permanence. Consid\u00e9rez chaque erreur du compilateur comme une opportunit\u00e9 d’apprentissage. Les messages d’erreur de Rust sont souvent tr\u00e8s descriptifs et vous guident vers la bonne solution. Au fil du temps, vous constaterez que ces erreurs vous aideront \u00e0 \u00e9crire un code de meilleure qualit\u00e9 et plus s\u00fbr.<\/li>\n
- Soyez patient.<\/strong> On peut facilement se d\u00e9courager avec Rust. Rappelez-vous que Rust est con\u00e7u pour \u00eatre s\u00fbr et efficace, ce qui demande d’apprendre des concepts complexes. Faites des pauses lorsque vous en ressentez le besoin et n’h\u00e9sitez pas \u00e0 revenir sur des sujets plusieurs fois jusqu’\u00e0 ce que vous soyez s\u00fbr de les avoir bien compris.<\/li>\n
- Rejoignez des groupes d’apprentissage de Rust. <\/strong>De nombreux d\u00e9veloppeurs apprennent Rust et rejoindre un groupe peut vous apporter soutien et motivation. Recherchez des meetups ou des groupes d’\u00e9tude en ligne, ou apprenez en m\u00eame temps q’un ami.<\/li>\n<\/ol>\n
Ma\u00eetriser Rust prend du temps, mais le jeu en vaut la chandelle. Les avantages de Rust, telles que les garanties qu’il offre en mati\u00e8re de s\u00e9curit\u00e9 de la m\u00e9moire et ses performances, en font un langage puissant pour la programmation syst\u00e8me et le d\u00e9veloppement web, entre autres. Pers\u00e9v\u00e9rez et vous constaterez que l’utilisation de Rust peut \u00eatre plaisante et gratifiante.<\/p>\n
Cr\u00e9er des applications concr\u00e8tes avec Rust\u00a0<\/h2>\n
Examinons maintenant rapidement les avantages de Rust pour la cr\u00e9ation d’applications concr\u00e8tes. Nous allons \u00e9voquer plusieurs des domaines technologiques pour lesquels Rust est pertinent, avec des cas d’usages qui mettent en \u00e9vidence ses atouts et son utilit\u00e9.<\/p>\n
Rust pour le d\u00e9veloppement web<\/h3>\n
L’\u00e9cosyst\u00e8me de Rust est parfaitement adapt\u00e9 au d\u00e9veloppement web backend. De nombreux frameworks et biblioth\u00e8ques effectuent des t\u00e2ches g\u00e9n\u00e9rales de d\u00e9veloppement web (routage de requ\u00eates HTTP, gestion de formulaires et de JSON, cr\u00e9ation de mod\u00e8les, acc\u00e8s aux bases de donn\u00e9es, authentification et autorisation, journalisation et tra\u00e7age, etc.), avec des performances ad\u00e9quates pour la production. Je vous recommande de consulter le site web AreWeWebYet?<\/a> pour plus de d\u00e9tails ainsi que des liens utiles. Spoiler : la r\u00e9ponse \u00e0 la question que pose le site est oui.\u00a0<\/p>\n
\n![\"\"](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2024\/09\/image-21.png\")
<\/figure>\n<\/div>\nLa plupart des frameworks web pour Rust sont assez faciles \u00e0 utiliser d\u00e8s le d\u00e9part et offrent une documentation de qualit\u00e9, en partie du fait de la concurrence qui r\u00e8gne entre eux. La communaut\u00e9 Actix Web<\/a> propose notamment une collection d’exemples<\/a> int\u00e9ressante et \u00e0 jour. Mon coll\u00e8gue Khalid Abuhakmeh a \u00e9crit un tutoriel pour les d\u00e9butants<\/a> sur la cr\u00e9ation d’une application web HTML simple qui utilise Rocket, un autre framework web pour Rust, comme backend. Luca Palmieri, que j’ai mentionn\u00e9 plus t\u00f4t, est l’auteur du livre Zero To Production in Rust<\/em><\/a>, qui est un guide pour devenir d\u00e9veloppeur web backend. Il travaille \u00e9galement sur Pavex<\/a>, un framework web \u00e9mergent et prometteur. Fait notable concernant ce dernier projet, Luca documente soigneusement les choix de conception dans une s\u00e9rie de rapports d’avancement<\/a>. Il est r\u00e9ellement int\u00e9ressant de d\u00e9couvrir et de comprendre les raisons de ces choix. Consultez cette comparaison de frameworks web<\/a> pour comprendre \u00e0 quel point les frameworks web Rust se d\u00e9veloppent.<\/p>\n
Rust est \u00e9galement actif dans le frontend web, m\u00eame s’il n’est peut-\u00eatre pas encore pr\u00eat \u00e0 100\u00a0% pour la production. N\u00e9anmoins, ses avanc\u00e9es concernant WebAssembly et les frameworks comme egui<\/a> ou Dioxus<\/a> sont impressionnantes.<\/p>\n
Int\u00e9gration de Rust avec d’autres langages de programmation<\/h3>\n
Je me demande si les concepteurs de Rust avaient imagin\u00e9 que Rust deviendrait l’un des langages de pr\u00e9dilection des personnes d\u00e9veloppant des outils et des biblioth\u00e8ques pour d’autres langages, en particulier pour Python et JavaScript. Rust peut offrir de meilleures performances, et il est suffisamment attrayant pour que les d\u00e9veloppeurs des \u00e9cosyst\u00e8mes d’autres langages se mettent \u00e0 l’apprendre et \u00e0 l’adopter.\u00a0<\/p>\n
Le projet PyO3<\/a> permet aux d\u00e9veloppeurs d’impl\u00e9menter des modules Python natifs en Rust et d’acc\u00e9der \u00e0 Python dans les binaires Rust. Gr\u00e2ce \u00e0 PyO3, vous pouvez fournir une impl\u00e9mentation Rust extr\u00eamement efficace d’une biblioth\u00e8que Python pour les d\u00e9veloppeurs Python. Rust et JavaScript peuvent \u00eatre connect\u00e9s de fa\u00e7on similaire via WebAssembly et wasm-bindgen<\/a>.\u00a0<\/p>\n
Astral<\/a> et son cr\u00e9ateur, Charlie Marsh, prouvent qu’il est possible de d\u00e9velopper des outils Python qui fonctionnent \u00e0 la vitesse de la lumi\u00e8re (enfin, nous savons tous que c’est une affirmation marketing, bien s\u00fbr, mais le r\u00e9sultat est vraiment fascinant).\u00a0<\/p>\n
![\"\"](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2024\/09\/image-27.png\")
<\/figure>\nDeno<\/a>, un runtime JavaScript d\u00e9velopp\u00e9 en Rust, offre de tr\u00e8s bonnes performances. Ce n’est pas le seul exemple dans l’\u00e9cosyst\u00e8me JavaScript. Il existe m\u00eame une collection d’outils JavaScript<\/a> impl\u00e9ment\u00e9s en Rust.\u00a0<\/p>\n
Impl\u00e9menter une interop\u00e9rabilit\u00e9 entre Rust et d’autres langages de programmation est \u00e9galement possible.<\/p>\n
Syst\u00e8mes et programmation embarqu\u00e9e en Rust<\/h3>\n
Rust brille incontestablement dans le domaine de la programmation de syst\u00e8mes. Les intervenants de Google et de Microsoft confirment<\/a> que l’introduction de Rust dans leurs bases de code r\u00e9duit le nombre de vuln\u00e9rabilit\u00e9s de s\u00e9curit\u00e9, augmente les performances et maintient ou voire am\u00e9liore la productivit\u00e9 des \u00e9quipes de d\u00e9veloppeurs de logiciels. Amazon prend non seulement en charge le d\u00e9veloppement Rust sur AWS<\/a>, mais l’utilise \u00e9galement directement pour impl\u00e9menter sa propre infrastructure<\/a>. Cloudflare, une entreprise qui cr\u00e9e des r\u00e9seaux de diffusion de contenu et d’autres infrastructures r\u00e9seau, utilise Rust<\/a> dans de nombreux projets de bas niveau et contribue \u00e0 l’\u00e9cosyst\u00e8me Rust avec ses frameworks<\/a>. Ferrous Systems, une soci\u00e9t\u00e9 qui soutient le d\u00e9veloppement de rust-analyzer, d\u00e9veloppe \u00e9galement Ferrocene<\/a>, une suite d’outils Rust certifi\u00e9e pour les applications critiques. Cela permet d’utiliser Rust dans les industries automobile et a\u00e9rospatiale. On trouve notamment des rapports concernant l’utilisation de Rust par Volvo<\/a> et Renault<\/a> pour leurs logiciels embarqu\u00e9s.<\/p>\n
Conclusion et prochaines \u00e9tapes<\/h2>\n
Rust est un langage prometteur, qui a l’avantage de disposer de nombreuses ressources d’apprentissage et d’une communaut\u00e9 active et accueillante pour les d\u00e9butants. M\u00eame s’il pr\u00e9sente certains d\u00e9fis, compte tenu de ses concepts fondamentaux uniques, il existe \u00e9galement des moyens de les relever. Un fois que vous ma\u00eetriserez son utilisation, de nombreuses opportunit\u00e9s d’emploi dans diff\u00e9rents domaines s’ouvriront \u00e0 vous.\u00a0<\/p>\n
J’esp\u00e8re que les conseils et les ressources que j’ai pr\u00e9sent\u00e9s dans cet article vous aideront dans votre parcours. Je vous recommande surtout de vous fixer un objectif avant de vous lancer : trouvez un projet open source auquel vous souhaitez contribuer ou d\u00e9veloppez une id\u00e9e pour votre projet d\u00e8s le d\u00e9but. Vous serez \u00e9tonn\u00e9 de la rapidit\u00e9 avec laquelle vous parviendrez \u00e0 vous rapprocher de l’atteinte de cet objectif.<\/p>\n
Je vous souhaite le meilleur dans votre aventure d’apprentissage de Rust !<\/p>\n
Auteur de l’article original en anglais<\/em> :<\/p>\n\n
\n\n\n\n![\"Vitaly](\"https:\/\/blog.jetbrains.com\/wp-content\/uploads\/2022\/06\/2019-08-10-14-42-05_1568979197310-1-200x200.jpg\")
\n <\/div>\n - Prenez votre temps avec le v\u00e9rificateur d’emprunt.<\/strong> Le v\u00e9rificateur d’emprunt peut \u00eatre frustrant, car il est strict et peut conduire \u00e0 des erreurs de compilation d\u00e9routantes. Lorsque vous rencontrez des probl\u00e8mes avec le v\u00e9rificateur d’emprunt, prenez du recul et analysez ce que Rust essaie d’\u00e9viter. Exp\u00e9rimentez avec des approches telles que le r\u00e9f\u00e9rencement ou le clonage de donn\u00e9es (mais essayez de ne pas tout cloner\u00a0!). N’h\u00e9sitez pas \u00e0 demander de l’aide sur des forums comme Reddit ou le serveur Rust Community sur Discord. Il est vraiment utile de comprendre ce qu’est pr\u00e9cis\u00e9ment un v\u00e9rificateur d’emprunt. Consultez, par exemple, cette excellente explication<\/a> de Nell Shamrell-Harrington.<\/li>\n
- En tant que d\u00e9butant, vous pouvez poser vos questions sur le serveur Discord de la communaut\u00e9 Rust<\/a>.<\/li>\n
- Jeremy Chone<\/a> est tr\u00e8s dou\u00e9 pour expliquer des concepts complexes.<\/li>\n
- Rustlings<\/a> (et sa variation pour une exp\u00e9rience d’apprentissage dans l’IDE<\/a>, un cours<\/a> sur Rust de JetBrains Academy<\/a>).<\/li>\n
- Rust in Action<\/em><\/a> par Tim McNamara (\u00e9galement connu sous le nom de timClicks<\/a>\u00a0; mon conseil est de le suivre partout).<\/li>\n
- The Rust Programming Language<\/em><\/a> est un livre officiel sur le langage r\u00e9guli\u00e8rement actualis\u00e9, destin\u00e9 aux personnes qui apprennent Rust. Il est connu sous le nom de The Book<\/em> au sein de la communaut\u00e9. Je recommande \u00e9galement une autre version<\/a> de ce livre qui apporte plus d’interactivit\u00e9, avec des quiz, des visualisations et des exercices. Cette version a \u00e9t\u00e9 d\u00e9velopp\u00e9e par Will Crichton, Gavin Gray et Shriram Krishnamurthi, chercheurs \u00e0 l’Universit\u00e9 Brown. Il existe \u00e9galement une une interview<\/a> avec Will Crichton, dans laquelle il explique cette exp\u00e9rimentation pour am\u00e9liorer l’exp\u00e9rience des personnes apprenant Rust.<\/li>\n
- Chaque fragment de m\u00e9moire doit appartenir \u00e0 une seule variable : le mod\u00e8le de propri\u00e9t\u00e9<\/em> de Rust repose sur ce point.<\/li>\n
- Les d\u00e9veloppeurs qui travaillent d\u00e9j\u00e0 avec Rust n’envisagent aucunement de passer<\/a> \u00e0 un autre langage de programmation.<\/li>\n<\/ul>\n