IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)

Vous êtes nouveau sur Developpez.com ? Créez votre compte ou connectez-vous afin de pouvoir participer !

Vous devez avoir un compte Developpez.com et être connecté pour pouvoir participer aux discussions.

Vous n'avez pas encore de compte Developpez.com ? Créez-en un en quelques instants, c'est entièrement gratuit !

Si vous disposez déjà d'un compte et qu'il est bien activé, connectez-vous à l'aide du formulaire ci-dessous.

Identifiez-vous
Identifiant
Mot de passe
Mot de passe oublié ?
Créer un compte

L'inscription est gratuite et ne vous prendra que quelques instants !

Je m'inscris !

Brian Kernighan, co-créateur d'Unix, s'exprime après avoir testé le langage Rust : « je ne pense pas qu'il va remplacer C tout de suite »,
Il juge l'écosystème de Rust « incompréhensiblement vaste et lent »

Le , par Mathis Lucas

411PARTAGES

15  0 
Brian Kernighan, co-créateur d'Unix, a partagé ses réflexions sur les langages modernes tels que Rust, les distributions Linux et les descendants d'Unix. Il a souligné que les solides fonctionnalités de sécurité mémoire de Rust font des vagues dans la communauté, offrant aux développeurs un moyen d'écrire du code plus sûr. Toutefois, après l'avoir testé, Brian Kernighan juge l’écosystème de Rust « incompréhensiblement vaste et lent ». Il n'a écrit qu'un seul programme en Rust, mais rapporte une expérience pénible. Son avis contraste avec celui d'autres figures de l'industrie, comme Linus Torvalds, créateur du noyau Linus.

Brian Kernighan, 83 ans, est un informaticien canadien de renom connu pour avoir coécrit le premier livre sur le langage de programmation C (avec Dennis Ritchie). Il est également le co-créateur des langages Awk, avec Alfred Aho et Peter Weinberger, et AMPL. Il a travaillé aux Bell Labs et a contribué au développement d'Unix aux côtés des créateurs d'Unix, Ken Thompson et Dennis Ritchie. Il est aussi connu pour d'autres travaux pionniers dans l'informatique.

En 1969, il obtient un doctorat d'électrotechnique à l'université de Princeton, où en 2004, il occupe un poste de professeur. « J'enseigne toujours à Princeton. Je n'ai pas encore pris ma retraite ! », a-t-il déclaré récemment, devant un public réuni au InfoAge Science and History Museums de Wall, dans le New Jersey.

Brian Kernighan avait été invité à prendre la parole lors du festival « Vintage Computer East ». Lors de l'événement, il a partagé ses réflexions sur ce qu'il pense du monde d'aujourd'hui, avec son abandon du langage C au profit de langages de programmation plus sûrs pour la mémoire. Il a mis l'accent sur le langage Rust, qu'il a utilisé pour écrire un programme. Mais alors que Rust jouit d'une popularité croissant, Brian Kernighan n'a pas du tout été séduit.

Brian Kernighan critique vivement les performances du langage Rust

« Pensez-vous que Rust ait un quelconque intérêt à remplacer C ? Ou s'agit-il simplement d'un énorme battage médiatique qui finira par s'essouffler ? », a demandé un membre du public. Dans un monde qui évolue depuis des années vers des langages plus sûrs pour la mémoire, la réponse d'un fervent défenseur du langage de programmation C depuis plus d'un demi-siècle promettait d'être tout simplement emblématique. Il s'est montré très très critique.

Brian Kernighan a trouvé son expérience avec Rust « pénible ». Selon lui, les mécanismes imposés par Rust pour garantir la sécurité mémoire sont trop lourds, surtout dans un programme où la gestion de la mémoire n’était pas un problème majeur. Il décrit son unique essai comme « une douleur », et juge l’écosystème du langage — avec ses crates, sa complexité et la lenteur de la compilation — comme « incompréhensiblement vaste et lent ».


« Ohhh, Rust », a déclaré Brian Kernighan, sous les rires du public. « Je n'ai écrit qu'un seul programme en Rust, vous devez donc prendre tout cela avec beaucoup de recul. Et j'ai trouvé cela pénible. Je n'arrivais tout simplement pas à comprendre les mécanismes nécessaires pour assurer la sécurité de la mémoire, dans un programme où la mémoire n'était même pas un problème ! ». Sa plus grande critique semble concerner ses performances de Rust.

« Et le compilateur était lent, le code qui en ressortait était lent... », a-t-il déclaré. « Quand j'ai essayé de comprendre ce qui se passait, le langage avait changé depuis la dernière fois que quelqu'un avait publié une description ! Il m'a donc fallu plusieurs jours pour écrire un programme qui, dans d'autres langages, aurait pris peut-être cinq minutes... »

Le 15 mai 2025, le compte Twitter officiel du projet FFmpeg a publié un message acerbe à l'encontre de Rust qui dit : « [Rust] est tellement bon que l'on peut être payé 20 000 $ pour le rendre aussi rapide que C ». Cette remarque visait l'initiative de Prossimo, qui a proposé une prime de 20 000 $ à quiconque parviendrait à rendre son décodeur AV1, rav1d, aussi rapide que dav1d, une implémentation en C largement reconnue pour sa rapidité.

Cette déclaration a ravivé le débat sur les compromis entre sécurité mémoire, performance et coût dans le développement de systèmes critiques. Il s'agit d'un débat de longue date dans la communauté des développeurs. Certains chérissent les performances brutes, tandis que d'autres préfèrent la sécurité.

Les limites du jugement de Brian Kernighan concernant le langage Rust

Dans l'ensemble, Brian Kernighan avait eu une mauvaise expérience. Il reconnaît qu’il n’a écrit qu’un seul programme en Rust et conseille de prendre ses critiques avec prudence. Il précise que son expérience reste personnelle et ne doit pas être vue comme un rejet définitif du langage. Cela dit, il ne considère pas Rust comme un remplaçant du C : « je suis probablement trop cynique. Mais je ne pense pas qu'il va remplacer C tout de suite, en tout cas ».

La position de Brian Kernighan sur Rust contraste avec celle de Linus Torvalds, créateur du noyau Linux. Linus Torvalds est favorable à l'introduction de Rust dans le noyau Linus, ce qui constitue l’un des changements techniques les plus significatifs de ces dernières années. Le langage de programmation Rust, réputé pour sa sécurité mémoire et sa modernité par rapport au langage C, a suscité un débat très intense parmi des développeurs du noyau.

Depuis l'annonce de la prise en charge expérimentale de Rust dans le noyau Linux, plusieurs mainteneurs ont exprimé des inquiétudes quant à l'impact de ce changement. Parmi eux, Christoph Hellwig a pris une position ferme contre l'utilisation de Rust, mettant en avant des arguments relatifs à la complexité et à la fragmentation du développement du noyau. Les critiques craignent que le mélange de Rust et du C ne rende Linux impossible à maintenir.

Face aux préoccupations soulevées, Linus Torvalds a clarifié sa position sur Rust. Il a affirmé qu'il n'est pas question d'imposer Rust aux mainteneurs qui ne souhaitent pas travailler avec ce langage. Linus Torvalds a expliqué que les mainteneurs ne seront pas contraints d'interagir avec du code Rust s'ils n'en voient pas l’utilité. Cependant, cela ne signifie pas qu'ils ont le droit de bloquer son intégration dans des domaines où il est jugé bénéfique.

Linus Torvalds a précisé que la demande d’intégration d’un module en Rust, qui était à l’origine du débat, n’avait aucune incidence directe sur le code...
La fin de cet article est réservée aux abonnés. Soutenez le Club Developpez.com en prenant un abonnement pour que nous puissions continuer à vous proposer des publications.

Une erreur dans cette actualité ? Signalez-nous-la !

Avatar de RenarddeFeu
Membre averti https://www.developpez.com
Le 03/09/2025 à 7:14
Le juge de paix, ce sont les utilisateurs qui adopteront ou non le langage. Les qualités intrinsèques d'un langage de programmation n'ont jamais été gage popularité. Et a contrario, beaucoup de langages largement utilisés sont juste horribles.
7  0 
Avatar de fdecode
Membre habitué https://www.developpez.com
Le 02/09/2025 à 10:23
Est-il utile de relayer les arguments un peu creux d'une personne illustre qui donne un avis rapide sur un langage auquel il ne s'est visiblement pas intéressé (une programmation qui aurais dû prendre 5 minutes...) et auquel il n'a pas l'intention de s'intéresser. Il mérite certainement mieux que ça:
« Je n'ai écrit qu'un seul programme en Rust, vous devez donc prendre tout cela avec beaucoup de recul. Et j'ai trouvé cela pénible. Je n'arrivais tout simplement pas à comprendre les mécanismes nécessaires pour assurer la sécurité de la mémoire, dans un programme où la mémoire n'était même pas un problème ! »
« Quand j'ai essayé de comprendre ce qui se passait, le langage avait changé depuis la dernière fois que quelqu'un avait publié une description ! Il m'a donc fallu plusieurs jours pour écrire un programme qui, dans d'autres langages, aurait pris peut-être cinq minutes... »
Le langage ou un crate? Parce que le langage est plutôt stable d'une version à l'autre... Lors d'un changement d'édition, il peut y avoir des changements notables, mais même là, la transition reste relativement simple.
4  1 
Avatar de OuftiBoy
Membre éprouvé https://www.developpez.com
Le 03/09/2025 à 16:07


Je suis plutôt d'accord avec RenarddeFeu, ce sont les utilisateurs qui choisiront au final. Rust est un langage avec des qualités, c'est certains. Mais il n'est déjà plus tout jeune (il a plus de 10 ans si je ne me trompe). 10 ans, en informatique, c'est long, et cela n'a pas pourtant permit à 'Rust' de s'imposer.

Il gagne en popularité, mais il a une courbe d'apprentissage qui me semble (ce n'est que mon opinion...) plus ardue, une communauté ayant un esprit "élitiste" (c'était en tout cas mon sentiment lorsque j'ai tenté d'approfondir ma connaissance de Rust), une syntaxe assez "rebutante" (à laquelle on peut certes s'habituer par la pratique, rien d'insurmontable), et utilise des "termes" ou un vocabulaire (comme "crate" par exemple) "déroutant".

Rust est un (très) bon langage, mais tous ces "petits détails" (courbe d'apprentissage ardue, communauté élitiste, syntaxe rebutante, vocabulaire déroutant) sont des freins à son adoption plus "massive". On dirait même qu'il fait tout pour ne pas être aimé.

Mais ce n'est que mon avis, chacun à le sien, et les utilisateurs (les développeurs) trancheront.

BàV et Peace & Love.
3  0 
Avatar de fdecode
Membre habitué https://www.developpez.com
Le 03/09/2025 à 18:39

Brian Kernighan juge l’écosystème de Rust « incompréhensiblement vaste et lent ». Êtes-vous de cet avis ?
En fait il est très simple de compter les composants de la librairie standard Rust.

Les crates qui composent le langage Rust sont: alloc, core, proc_macro, std, test.

Mais pour toute utilisation ordinaire, le langage Rust, c'est essentiellement la librairie standard std:
https://doc.rust-lang.org/stable/std/all.html
soit environ 2000 composants (toutes structures, primitives, traits, macros, fonctions, alias, constantes confondues) publiquement affichés dans la librairie standard.

Dans les faits, std utilise des composants bas niveaux de core et alloc, mais cela est transparent pour l'utilisateur lambda. Personnellement, je n'utilise jamais core ni alloc.

Si on fait du no_std, on doit passer par le core et alloc:
https://doc.rust-lang.org/stable/core/all.html
https://doc.rust-lang.org/stable/alloc/all.html
alloc comprends à peu près 250 composants et core, quant à lui, est bien plus gros (environ 25000 composants définis), car le core met à disposition des implémentations bas niveau très spécifiques pour différentes architectures matérielles. Cela a un effet démultiplicateur.

Les autres crates du langage Rust, proc_macro, test, ne représentent pas grand chose numériquement.

Est-ce incompréhensiblement vaste? Pour être honnête, il faudrait comparer std aux librairies standards C et C++ (core et alloc ne correspondent pas à un usage standard de Rust).
Il me semblait avoir lu que les composants de la librairies standard C se comptaient en centaines et que ceux de C++ étaient autour des 10000. Mais ce serait à confirmer. Pour que les comparaisons se valent, il faudrait compter les composants déclarés à l'intérieur des header...

---

En revanche, pour ce qui est du site de dépôt crates.io, il y a près de 200000 crates. Mais cela est en dehors de la librairie std ou no_std. N'importe qui peut déposer un crates sur crates.io...


Pensez-vous que la complexité apparente de Rust est un obstacle réel à son adoption, ou bien seulement une difficulté passagère pour les nouveaux venus ?
J'ai accroché tout de suite. Mais chaque codeur a ses affinités linguistiques.


Selon vous, un langage de programmation doit-il viser d’abord la simplicité d’usage ou la robustesse et la sécurité ?
La difficulté dans beaucoup de langages est implicite, alors qu'elle est plutôt explicite en Rust. En ce sens, la question est mal posée.
En pratique, j'utilise des IA comme aide pour la programmation C++ (avoir le bon usage des différents standards) et Python (notamment pour maitriser numpy, pytorch et tensorflow). Je n'ai pas besoin de cette aide en Rust. Et là on parle de chose qui ne concernent pas seulement la sécurité.


L’avis d’un pionnier comme Brian Kernighan a-t-il encore du poids pour juger les langages modernes, ou bien son expérience est-elle trop marquée par d’autres époques ?
Brian Kernighan est plutôt prudent et honnête dans sa réponse. Son jugement et ses conseils ont certainement un intérêt mais pas sur un sujet qu'il ne connait pas vraiment. Et c'est ce qu'il dit... C'est pour cette raison que je trouve inadéquat des titres comme Brian Kernighan critique vivement les performances du langage Rust.


Selon vous, Rust pourra-t-il un jour remplacer le langage C dans les systèmes critiques,
Je ne me suis jamais posé la question en termes de remplacement...

La programmation no_std peut s'appliquer à de la programmation embarquée ou à de la programmation système,
https://www.redox-os.org/
https://www.rust-lang.org/what/embedded

en revanche, il faudra certainement aller vers des certifications pour des systèmes critiques. Il y a en tout cas des actions à ce sujet:
https://rustfoundation.org/safety-cr...st-consortium/


ou restera-t-il un langage de niche ?
De quelle niche parle-t-on?
3  0 
Avatar de OuftiBoy
Membre éprouvé https://www.developpez.com
Le 09/09/2025 à 13:22
fdecode

Citation Envoyé par fdecode Voir le message
Puisque vous avez intensément étudié ces questions d'ownership, vous savez donc que l’ownership n’est pas une lourdeur inventée par Rust, mais une réalité universelle : dans tout langage, il faut décider qui possède quoi, combien de temps ça vit, et quand on peut le partager. La différence, c’est que Rust choisit de l’exprimer clairement et de le vérifier à la compilation, là où d’autres laissent le soin au programmeur (C++) ou au GC (Java).
Je ne dis pas le contraire, il faut évidemment (dans tout langage) décider qui possède quoi, combien de temps ça vit, et quand on peut le partager. C'est comme vous dites "une réalité universelles". Et je suis encore d'accord avec vous que les moyens employés par Rust, vérifiables à la compilation, apportent une plus-value. Par contre, je trouve (c'est un avis personnel, d'autres peuvent penser le contraire, cela dépend comment on "ressent" les choses), je ne trouve pas que les mécanismes de Rust (qui sont très valables, je ne dis pas le contraire) peuvent être exprimés si "clairement" que cela.

Citation Envoyé par fdecode Voir le message
Dans C++, les deux types de référence T& et T&& permettent respectivement de distinguer entre une référence à une donnée du processus appelant et un transfert d'ownership vers l'appelé. Les pointeurs intelligents du C++ sont aussi un moyen de gérer l'ownership au niveau d'un pointeur compté.
Honnêtement, je me suis "détourné" du C++ il y a déjà bien longtemps. Je pourrais palabrer pendant des heures sur ce sujet, mais ce n'est le sujet... Je n'intervenais pas pour dénigrer Rust, loin de là, mais en réaction à l'article où Brian Kernighan exprimait qu'il avait trouvé difficile d'appréhender ces concepts, et que si un développeur de son calibre a eu des soucis avec cela, d'autres développeurs peuvent également avoir une grande difficulté à les assimiler et à les utiliser.

Citation Envoyé par fdecode Voir le message
Le borrowing et les lifetimes sont des outils pour clarifier des cas particuliers (emprunt temporaire, partage, multithreading). C’est vrai qu’il y a une marche d’apprentissage, mais une fois passée, on gagne énormément en robustesse et en sérénité.
Je ne pense pas avoir dis le contraire, vous dites vous-même qu'il y a cette "marche" d'apprentissage, qui peut sembler facile pour certains, mais compliquée par d'autres. Cela n'enlève rien au fait qu'avec l'utilisation des ces outils, Rust aide a produire un code plus "secure" et offre par la suite, une robustesse et une sérénité.

Citation Envoyé par fdecode Voir le message
C'est une vision fantasmée des langages de programmation. Compte tenu de la place occupée par le C++ et le C dans les produits existants, je pense que personne n'a jamais sérieusement fait l'hypothèse que Rust pourrait s'imposer face au C++ en 10 ans. D'ailleurs quand on voit que Google (contributeur platinum de la fondation Rust) a offert un financement pour l'interopérabilité Rust/C++, cela montre bien que même les soutiens de premier plan du langage le voient coexister dans un écosystème avec d'autres langages. Et je partage cette vision.
Il y a tout de même "un mouvement" qui tend a cesser d'utiliser "C++" et d'utiliser "Rust" à la place. Il est évident que cela ne peut se faire du jour au lendemain, de part la base de code immense développées en C/C++, je suis tout à fait d'accord avec vous sur ce point. 10ans, ce n'est peut-être pas assez, je vous l'accorde, mais "le COBOL", dans le domaine bancaire, reste largement utilisé, car rien n'as pu venir le remplacer. Certains ont essayer avec Java, mais sans succès.

Par contre, la coexistence de plusieurs langages dans un même produit, je ne suis pas fan. Cela ajoute une couche de complexité dans la "chaîne de production" du logiciel. Et il faut alors "trouver" des développeurs avec une bonne expérience dans 2 langages pour participer au développement du projet, ce qui, actuellement encore, n'est pas si facile a trouver.

Oui, Rust est supporté par des grands acteurs, mais il n'en reste pas moins vrai que dans certains domaines (l'embarqué), le premier langage disponible est toujours le C. Il y a, c'est vrai, des compilateurs Rust même pour certains microcontrôleurs, mais ils viennent après le C et ne sont pas si rependus que cela. Si, pour une raison quelconque il faut changer de microcontrôleur dans un firmware, que ce "firmware" a été écrit en "Rust", et qu'il n'y a pas de compilateur Rust pour ce dernier, cela pose un grand soucis...

Citation Envoyé par fdecode Voir le message
Rust n’a pas de classes, ce qui l’éloigne fondamentalement de la syntaxe de C++. Sa hiérarchie des types concrets (struct, enum, union, tableaux, primitives, …) reste proche d’une philosophie C, même si elle est enrichie de subtilités comme les encodages (repr).

Les traits définissent une hiérarchie de comportements (ou de capacités), orthogonale à la hiérarchie des types concrets : ils n’altèrent pas ces structures simples. On peut former des trait objects, mais il y a toujours un type concret en arrière-plan.

Rust n’emprunte donc pas l’approche hiérarchique de C++ (héritage de classes qui mêle structure et comportement), mais propose une alternative orthogonale : des traits pour exprimer les comportements, et des génériques pour composer ces comportements. À mes yeux, c’est une approche alternative qui prolonge l’esprit du C : un langage bas niveau, mais cette fois sécurisé et enrichi de concepts objets, sans impact direct sur l’organisation nominale des types concrets.
Je vous fais confiance sur cet aspect, je n'ai pas étudier Rust dans son ensemble, je me suis attardé sur les principes utilisés pour la "sécurisation" de la mémoire, et j'y ai vu une "ressemblance" syntaxique avec le C/C++. C'est peut-être une fausse "impression", mais c'est ce que j'ai ressenti.

Citation Envoyé par fdecode Voir le message
Cela n’empêche pas le système de traits, associé aux génériques et aux macros procédurales (travaillant sur l’AST), d’être extrêmement puissant.
Je suis 100% d'accord avec vous, la POO tel qu'implémentée dans le C++, Java n'est pas l'approche que je préfère. Une approche plus basée sur le comportement plutôt que sur les "données" d'un objet est pour moi, bien plus pertinent. L'encapsulation et l'héritage sont souvent à l'origine d'architectures de code difficiles à suivre et a faire évoluer. Il faut privilégier la composition à l'héritage, et travailler en utilisant des interfaces et non des "types concrets".

Citation Envoyé par fdecode Voir le message
Je ne me risquerais pas à définir de telles frontières. Vous avez du Rust dans Redox-OS -- l’essentiel du code (noyau, pilotes, bibliothèques, espace utilisateur), à l’exception de quelques routines assembleur très bas niveau et d’un peu de code C dans relibc, soit en cours de transition vers Rust, soit maintenu pour assurer certaines compatibilités POSIX -- et il y a également de plus en plus de Rust dans Linux.... Je ne fais pas de Rust embarqué, mais cela aussi s'installe petit à petit.
Vous avez raison, les frontières sont plus floues en réalité, mais l'utilisation du C dans l'embarqué offre une garantie que Rust ne peut pas apporter actuellement. Ce sera peut-être dans quelques années ou peut-être pas.

Citation Envoyé par fdecode Voir le message
C'est un petit détail, mais ils attirent toujours mon attention: ARM est récemment devenu soutien platinum de la Rust Foundation. On a donc désormais 6 soutiens platinum à la Rust Foundation : AWS, Google, Meta, Microsoft, Huawei, ARM. La présence d'un acteur essentiellement matériel comme ARM donne une certaine perspective sur les évolutions de Rust.
Oui, mais il n'y a pas que des ARM qui sont utilisés dans l'embarqué... Parfois, pour gagner quelques centimes, on doit choisir un microcontrôleur pour y faire rentrer au chose-pied un firmware... Les "petits" détails attirent aussi mon attention

Je n'ai franchement pas l'envie ni le temps de "peser" le pour et le "contre" des attraits d'un langage par rapport à un autre. Tel n'était pas mon but dans ma réaction à l'article.

Mais je vous remercie de partager, de discuter, et de débattre courtoisement.

BàV et Peace & Love.
1  0 
Avatar de floyer
Membre éclairé https://www.developpez.com
Le 09/09/2025 à 16:31
Je cite : "L'encapsulation et l'héritage sont souvent à l'origine d'architectures de code difficiles à suivre et a faire évoluer. Il faut privilégier la composition à l'héritage, et travailler en utilisant des interfaces et non des "types concrets".

L'encapsulation permet au contraire de raisonner à plus haut niveau. Prenons une table de hashage (hash table). Tout ce que tu souhaites pour utiliser cette table est qu'il est possible d'y ajouter/supprimer/retrouver des information d'après leur clé. L'encapsulation permet cela en t'empêchant d'accéder au tableau qu'il y a derrière et programmer quelque chose qui cassera dès que le mainteneur de la table de hashage gangera des modalités interne. Je cite les table de hashage, mais les exemples ne manquent pas (driver SGBD, etc).

Par ailleurs, encapsulation et interfaces ne s'opposent pas bien au contraire. Le principe d'une interface est justement de décorréler données et traitement, et permettre de substituer une implémentation à une autre, voire permettre l'usage de plusieurs implémentation simultanément. Les interfaces sont indissociables de l'encapsulation.
1  0 
Avatar de fdecode
Membre habitué https://www.developpez.com
Le 10/09/2025 à 15:58
Citation Envoyé par OuftiBoy Voir le message
j'ai juste étudié son système de protection de la mémoire, qui même s'il est efficace, me semble inutilement "compliqué".
"inutilement compliqué" par rapport à quelle utilisation?
On n'est peut-être plus contraint aux seuls fork du C, mais faire de la programmation multithread ou concurrente bas niveau reste une tâche complexe. Rust avec son typage avec sémantique de prêt a grandement facilité ces paradigmes de programmation. Je parle de bas niveau ; car sinon, de nombreux langages à GC offrent des facilités pour la programmation multithread/concurrente (Erlang, Go, Clojure, Java, Scala/Akka, .NET, ...).

Citation Envoyé par OuftiBoy Voir le message
Les développeurs qui ont des problèmes avec les pointeurs sont souvent des développeurs ayant été formés sur des langage avec GC, et n'ont qu'une vague connaissance du bas-niveau des choses.
J'ai commencé assez jeune avec du 6502, du 86 en mode réel et du C. Pour autant, je reconnais honnêtement qu'il m'arrive de faire des erreurs dans ma gestion de la mémoire, lorsque j'en ai la responsabilité (C / C++). Ne soyons pas prétentieux!
1  0 
Avatar de Pat2kz
Nouveau Candidat au Club https://www.developpez.com
Le 07/09/2025 à 15:15
malgré les compétences indéniable de ce monsieur qui a grandement contribué à l'open source, je pense que là, il est un peu dépassé !??
il n'a écrit qu'un seul programme et peut déjà "dénigrer" Rust ?
rester sur C, C++, Java, etc, c'est une chose, mais heureusement que le langage informatique évolue et on doit aussi évoluer avec, comme la sécurité de Rust a été prouvée et c'est aussi de ce côté qu'on doit se diriger.
2  2 
Avatar de OuftiBoy
Membre éprouvé https://www.developpez.com
Le 08/09/2025 à 12:11
Pat2kz,

Citation Envoyé par Pat2kz Voir le message
malgré les compétences indéniable de ce monsieur qui a grandement contribué à l'open source, je pense que là, il est un peu dépassé !?? il n'a écrit qu'un seul programme et peut déjà "dénigrer" Rust ?
Dans l'article, il dit (je cite) : "Je n'ai écrit qu'un seul programme en Rust, vous devez donc prendre tout cela avec beaucoup de recul". Il est donc bien conscient et exprime son avis sur le sujet avec énormément de précaution, et apparemment, cela se déroulait dans une ambiance "légère", propice a se lâcher un peu.

Je ne suis absolument pas expérimenté en "Rust", mais bien en "C". Mais j'ai étudié la partie "sécurisation de la mémoire" de Rust, et lorsqu'il dit (je cite) : "Et j'ai trouvé cela pénible. Je n'arrivais tout simplement pas à comprendre les mécanismes nécessaires pour assurer la sécurité de la mémoire, dans un programme où la mémoire n'était même pas un problème !".

Le problème qu'il dénonce, c'est qu'il a eu du mal a comprendre les mécanismes de sécurisation de ma mémoire. Si un développeur de son niveau n'arrive que difficilement à comprendre ces mécanismes, on peut comprendre que nombres de développeurs lambda éprouvent eux aussi d'énormes difficultés avec la compréhension de ces mécanismes, non ?

Il ajoute (je cite) : "dans un programme où la mémoire n'était même pas un problème !". Je ne connais pas le programme qu'il a voulu écrire, mais sa parole étant "rare", j'ai tendance à le croire.

Ayant étudié de près ces mécanismes, et même si le résultat fait indéniablement de "Rust" un langage plus "secure" qu'un programme en "C", les mécanismes qu'il faut utiliser sont assez "lourds" (ce n'est que mon avis), le concept "d'ownership" montre vite ces "limites", d'où le "Borrowing" et son indispensable "Borrow Checker". Il faut ajouter à cela le concepts de "Lifetime". Cela fait quand même pas mal de concepts a intégrer.

Je pense que cela vient du fait que "Rust" n'a pas voulu trop s'éloigner du C++ (en terme de syntaxe), car son objectif est d'attirer à lui ces développeurs C++.

Citation Envoyé par Pat2kz Voir le message
rester sur C, C++, Java, etc, c'est une chose, mais heureusement que le langage informatique évolue et on doit aussi évoluer avec, comme la sécurité de Rust a été prouvée et c'est aussi de ce côté qu'on doit se diriger.
« Et le compilateur était lent, le code qui en ressortait était lent... », a-t-il déclaré. « Quand j'ai essayé de comprendre ce qui se passait, le langage avait changé depuis la dernière fois que quelqu'un avait publié une description ! Il m'a donc fallu plusieurs jours pour écrire un programme qui, dans d'autres langages, aurait pris peut-être cinq minutes... ».

Je ne sais pas me prononcer, et je suis certains que certains diront que ce sont plus les "libraires" qui évoluent que le langage lui-même. Mais "Rust" n'est plus tout jeune non plus, il a une dizaine d'années, et ce "temps" aurait du suffire pour qu'il s'impose face au C++, ce qui ne semble pas être le cas.

En fait, il est plus judicieux de comparer "Rust" à "C++" et pas au "C". Ce sont deux types d'outils (Rust et C++) et (le C) qui sont destinés a régler des problèmes différents, dans des contexte différents.

Perso, AMHA, je ne suis ni pour ni contre, et "comparer" des langages n'a pas pour moi beaucoup de sens. Comme toujours, il faut utiliser le bon outils adapté au travail a réaliser.

BàV et Peace & Love.
1  1 
Avatar de fdecode
Membre habitué https://www.developpez.com
Le 08/09/2025 à 20:02
Citation Envoyé par OuftiBoy Voir le message

Ayant étudié de près ces mécanismes, [...] le concept "d'ownership" montre vite ces "limites", d'où le "Borrowing" et son indispensable "Borrow Checker". Il faut ajouter à cela le concepts de "Lifetime".
Puisque vous avez intensément étudié ces questions d'ownership, vous savez donc que l’ownership n’est pas une lourdeur inventée par Rust, mais une réalité universelle : dans tout langage, il faut décider qui possède quoi, combien de temps ça vit, et quand on peut le partager. La différence, c’est que Rust choisit de l’exprimer clairement et de le vérifier à la compilation, là où d’autres laissent le soin au programmeur (C++) ou au GC (Java).

Dans C++, les deux types de référence T& et T&& permettent respectivement de distinguer entre une référence à une donnée du processus appelant et un transfert d'ownership vers l'appelé. Les pointeurs intelligents du C++ sont aussi un moyen de gérer l'ownership au niveau d'un pointeur compté.

Le borrowing et les lifetimes sont des outils pour clarifier des cas particuliers (emprunt temporaire, partage, multithreading). C’est vrai qu’il y a une marche d’apprentissage, mais une fois passée, on gagne énormément en robustesse et en sérénité.

Citation Envoyé par OuftiBoy Voir le message
il a une dizaine d'années, et ce "temps" aurait du suffire pour qu'il s'impose face au C++, ce qui ne semble pas être le cas.
C'est une vision fantasmée des langages de programmation. Compte tenu de la place occupée par le C++ et le C dans les produits existants, je pense que personne n'a jamais sérieusement fait l'hypothèse que Rust pourrait s'imposer face au C++ en 10 ans. D'ailleurs quand on voit que Google (contributeur platinum de la fondation Rust) a offert un financement pour l'interopérabilité Rust/C++, cela montre bien que même les soutiens de premier plan du langage le voient coexister dans un écosystème avec d'autres langages. Et je partage cette vision.

Citation Envoyé par OuftiBoy Voir le message

Je pense que cela vient du fait que "Rust" n'a pas voulu trop s'éloigner du C++ (en terme de syntaxe), car son objectif est d'attirer à lui ces développeurs C++.
Citation Envoyé par OuftiBoy Voir le message
En fait, il est plus judicieux de comparer "Rust" à "C++" et pas au "C".
Rust n’a pas de classes, ce qui l’éloigne fondamentalement de la syntaxe de C++. Sa hiérarchie des types concrets (struct, enum, union, tableaux, primitives, …) reste proche d’une philosophie C, même si elle est enrichie de subtilités comme les encodages (repr).

Les traits définissent une hiérarchie de comportements (ou de capacités), orthogonale à la hiérarchie des types concrets : ils n’altèrent pas ces structures simples. On peut former des trait objects, mais il y a toujours un type concret en arrière-plan.

Rust n’emprunte donc pas l’approche hiérarchique de C++ (héritage de classes qui mêle structure et comportement), mais propose une alternative orthogonale : des traits pour exprimer les comportements, et des génériques pour composer ces comportements. À mes yeux, c’est une approche alternative qui prolonge l’esprit du C : un langage bas niveau, mais cette fois sécurisé et enrichi de concepts objets, sans impact direct sur l’organisation nominale des types concrets.

Cela n’empêche pas le système de traits, associé aux génériques et aux macros procédurales (travaillant sur l’AST), d’être extrêmement puissant.
Citation Envoyé par OuftiBoy Voir le message
Ce sont deux types d'outils (Rust et C++) et (le C) qui sont destinés a régler des problèmes différents, dans des contexte différents.
Je ne me risquerais pas à définir de telles frontières. Vous avez du Rust dans Redox-OS -- l’essentiel du code (noyau, pilotes, bibliothèques, espace utilisateur), à l’exception de quelques routines assembleur très bas niveau et d’un peu de code C dans relibc, soit en cours de transition vers Rust, soit maintenu pour assurer certaines compatibilités POSIX -- et il y a également de plus en plus de Rust dans Linux.... Je ne fais pas de Rust embarqué, mais cela aussi s'installe petit à petit.

C'est un petit détail, mais ils attirent toujours mon attention: ARM est récemment devenu soutien platinum de la Rust Foundation. On a donc désormais 6 soutiens platinum à la Rust Foundation : AWS, Google, Meta, Microsoft, Huawei, ARM.
La présence d'un acteur essentiellement matériel comme ARM donne une certaine perspective sur les évolutions de Rust.
0  0