ariasuni a écrit 3200 commentaires

Rust est sans doute plus compliqué que Go mais plus sûr et plus rapide, et il est bien plus simple que le C++. En vérité, j’ai l’impression d’avoir du Python compilé typé statiquement, avec des trucs tirés de Go/langages fonctionnels.

Écrit en Bépo selon l’orthographe de 1990

Rust = rouille = trucs qui ont fait leurs preuves = pas nouveau. Ce qui est nouveau c’est plutôt de réunir toutes ces fonctionnalités dans un langage. Je connais (très) mal Go, c’est pour ça que je n’en ai pas parlé.

Après Rust est vachement plus rapide que Go je crois. Si ça t’intéresse, il y a la FAQ du wiki qui explique ce que Rust a en plus, et cet article qui montre plutôt les similitudes.

Tu as aussi cette discussion qui expose des points de vue intéressants: pour l’un Go serait pour remplacer plutôt Java et Python, pour l’autre Go va écraser Rust parce que Google a une force de frappe importante, et que Rust est trop complexe.

Je ne comprends pas trop les réactions, je trouve au contraire la syntaxe très simple et j’ai plutôt buté sur les boites (forcément, quand on présente les trois en même temps en anglais et que tu découvres le langage, c’est compliqué). Mais en fait à part ~ qui a un comportement un peu particulier, les autres sont très simples.

Après au niveau de la lisibilité, je trouve le code Rust beaucoup plus lisible que le C, C++ ou D (mais c’est peut-être dû en partie à coloration syntaxique différente).

Écrit en Bépo selon l’orthographe de 1990

J'aimerais bien savoir comment il empêche les doublons, parce que chez il empêche rien du tout.

L'histoire: sur mon téléphone portable, si je tape «Publier» sans faire exprès et que j'arrête le chargement de la page (ou si la connexion saute, relativement courant sur mobile) pour revenir en arrière puis poster, souvent le premier a déjà été publié.

Écrit en Bépo selon l’orthographe de 1990

Ah ouais, je ne pensais honnêtement pas que ça représentait autant de travail.

Écrit en Bépo selon l’orthographe de 1990

let c’est pour dire «tiens c’est une variable», le type d’une variable est déterminé à la compilation, et souvent déduit par Rust mais c’est possible de préciser tout le temps le type.

Je suis plutôt fan de l’annotation à la fin de la variable pour indiquer son type, par exemple let x = 1u; pour dire que c’est un entier non-signé, mais on peut indiquer de façon plus lisible le type, par exemple let x: uint = 1;.

Écrit en Bépo selon l’orthographe de 1990

C’est vrai qu’il y a beaucoup de fonctionnalités dans le D. On peut effectivement faire de la programmation par contrat, mais j’ai pas l’impression que la complexité de l’implémentation, l’augmentation de la complexité du langage et le coup en performances (je ne connais pas vraiment l’impact) vaut vraiment le coup. Après j’ai pas testé, je rate peut-être quelque chose de formidable! ^^

Écrit en Bépo selon l’orthographe de 1990

D'ailleurs, pour info, une grosse partie de la 0.8 et qui est encore en cours consiste à remplacer l'ancien runtime en C++ par un nouveau écrit en Rust. Il devrait avoir un système de planification des Task plus intelligent et améliorer les I/O.

Il y a déjà une bonne partie du runtime en Rust, non? En tout cas, les IO c’est un peu en chantier donc à part l’entrée et la sortie standard, pour le reste c’est compliqué de trouver de la documentation et compliqué à faire fonctionner. Les IO sont un point réellement complexe et c’est pas la première fois qu’il réécrivent cette partie de la bibliothèque standard (autant en profiter, parce qu’avec la version 1.0 on pourra faire beaucoup moins de changements).

Écrit en Bépo selon l’orthographe de 1990

Ça se démarque clairement surtout.

Écrit en Bépo selon l’orthographe de 1990

Disons que tu peux modifier le code suivant la déclaration et ça change le type. Je ne vois pas trop l’intérêt non plus, mais peut-être que j’en trouverais un, et ça montre que l’inférence de type de Rust est assez puissante quand même.

Écrit en Bépo selon l’orthographe de 1990

Si t’as pas compris l’intérêt du match avec la dépêche, je ne peux plus rien faire pour toi.

• on n’est pas obligé d’utiliser break;.
• on peut tester plusieurs valeurs dans une seule branche (plusieurs possibilités ou un intervalle).
• on peut déstructurer toutes les structures de données du langage (struct, enum, tuples…)
• le match doit être exhaustif pour compiler.
• on peut introduire une condition supplémentaire après le motif.

Un switch n’a vraiment pas grand chose à voir.

Écrit en Bépo selon l’orthographe de 1990

le match qui déchire ça race?

Écrit en Bépo selon l’orthographe de 1990

Je crois avoir bien indiqué dans la dépêche que rustboot ne faisait pas grand chose, donc je sous-entendait que celui-là était dans un état aussi «primitif» que le premier.

Après j’ai pas testé tous les projets — en fait aucun — mais en général c’est clairement indiqué sur la page Github que c’est en cours quoi.

En fait pour le moment c’est beaucoup de petits projets plus ou moins fonctionnels, faut dire que vu l’état actuel du Rust on n’a pas forcément envie de se lancer dans un gros projet, c’est plutôt des petits hobby qui peuvent donner quelque chose de sympa! Après j’ai quand même l’impression que les bindings au contraire sont plutôt pas mal.

C’est vrai que dans le feu de l’action, je ne pense pas à préciser ce qui me semble couler de source, vu que je suis le projet depuis un petit peu de temps déjà.

Écrit en Bépo selon l’orthographe de 1990

En tout cas, je sais qu’il a eu des discussions sur la liste de discussion pour faire tourner Rust sans OS (ça parlait de faire tourner Rust sur du Barebone).

Écrit en Bépo selon l’orthographe de 1990

C'est aussi une approche très fonctionnelle écrite avec une typo plus déclarative !

C’est exactement ce que je voulais mettre dans la dépêche mais je ne trouvais pas les mots, donc j’ai abandonné. Je trouve ça beaucoup plus lisible mais c’est sans doute parce que j’ai jamais utilisé aucun langage fonctionnel, c’est pour ça que je pense que pour ceux qui ont appris un langage procédural et impératif, ça doit être beaucoup plus facile d’apprendre le Rust que l’Haskell ou l’OCaml. En plus c’est des syntaxes qui font un peu peur au premier abord je trouve, même si après avoir pas mal testé le Rust j’adore toutes les fonctionnalités venant des langages fonctionnels! :)

Écrit en Bépo selon l’orthographe de 1990

Ça permet de savoir quand est-ce que c’est la déclaration, c’est plus facile à analyser syntaxiquement et à trouver avec grep ou simplement une recherche plein texte. Ou simplement l’humain, qui cherche les déclarations cherchera let et non int, float ou ArrayList<ArrayList<TrucÀLaCon>>, ou le nom de la variable (ce qui est encore plus chiant à trouver). Surtout que le mot-clé est tout le temps mis en surbrillance, contrairement à des noms de classe etc qui ne seront mis en avant que dans les IDE (et il n’y en a pas encore pour Rust de toute façon).

Bref, humain ou machine, même combat.

Écrit en Bépo selon l’orthographe de 1990

Pas vraiment un oubli, mais je viens de voir trois projets intéressant en passant sur le sous-reddit de Rust:

• Rustic Operating System, encore un système d’exploitation!
• ears, petite bibliothèque pour jouer du son, et utilise OpenAL et libsndfile. (Rappel: ne pas réinventer la roue!)
• Rust FUSE, pour utiliser FUSE avec Rust (merci captain obvious!).

Écrit en Bépo selon l’orthographe de 1990

Déjà de base les gestionnaires de fenêtres sont très chiants à porter sur Wayland vu que très liés à X.org. Donc s’ils ont une petite équipe, forcément…

Écrit en Bépo selon l’orthographe de 1990

Même en connaissant la règle, je ne suis pas sûr qu’on y pense spontanément.

Écrit en Bépo selon l’orthographe de 1990

Le souvenir que j'ai c'est : « Quoi ? On est 2 sur 25 à comprendre l'arithmétique des pointeurs ? »

Disons que moi la première c’était Site du Zéro, et comme j’avais pas beaucoup codé à part ça, c’était extrêmement difficile à comprendre. Et puis le temps est passé, et quand j’y suis revenu je comprenais déjà mieux, etc.

Donc ça dépend des cas. Une fois qu’on a compris c’est pas si compliqué, mais les pointeurs ça reste quand même assez casse-gueule.

Écrit en Bépo selon l’orthographe de 1990

J’ai oublié de parler de la visibilité des déclarations. C’est ça quand on fait une dépêche important sans marquer ce qu’il reste à faire… :p

Si on veut accéder à quelque chose déclaré dans un autre fichier, il faut qu’il soit marqué pub (pour publique). Par défaut, tout est privé (on peut l’indiquer en marquant priv).

On remarquera qu’encore une fois, les mots-clés sont concis mais toujours tout à fait compréhensibles (et c’est vachement agréable au quotidien).

pub struct Test { // on peut mettre un indicateur de visibilité sur une struct
    x: uint, // mais ça n’a pas de sens en Rust pour un attribut
    y: uint
}

impl Test { // ça n’a pas de sens non plus pour une `impl`
    pub new( … ) -> Test { … } // mais on peut sur des méthodes
}

priv trait Truc { // le trait ne sera accessible que dans son fichier
    fn machin( … ) { … } // la méthode est forcément publique dans un trait
}

Désolé, j’avais vraiment complètement zappé.

Écrit en Bépo selon l’orthographe de 1990

Comme tu le dis déjà, les pointeurs managé ne sont actuellement pas gérés par un ramasse-miettes, se sont en effet actuellement des pointeurs intelligents. Mais il y a déjà un "Cycle collector" sur ces pointeurs qui permet de résoudre les références circulaires.

C’est ce qu’on m’a dit sur IRC, donc faudrait quand même revérifier, parce que justement on m’a dit que le gros problème actuellement c’était les références circulaires. Ou alors c’est moi qui ai mal compris.

Un vrai ramasse-miettes devrait cependant permettre d'améliorer les performances a l'avenir.

Ça je l’ai dit, enfin pas que ça améliorait les performances mais ça me semblait évident.

"zero.rs" ne permet pas de supprimer l'OS mais le "runtime" du programme (un morceau de code qui gère le déroulement du reste du code). A noter d'ailleurs que "zero.rs" n'est plus nécessaire. Il suffit actuellement de poser une annotation pour produire un programme sans runtime.

J’ai dû mal comprendre alors, au temps pour moi.

Écrit en Bépo selon l’orthographe de 1990

les notions de "boites"/pointeurs sont plus nombreuses en Rust. L’analyse de cycle de vie d’un objet en Rust peut probablement perturber un développeur débutant.

À mon avis, si on explique bien et dans l’ordre ça va. Par exemple au début on apprend ~, ensuite & quand on commence à faire des fonctions, puis @ pour les besoins particuliers (et c’est pas difficile à comprendre ça marche tout seul!) et enfin * si on veut faire du code unsafe, ce dont on n’a absolument pas besoin quand on est débutant (sauf si on veut faire un fork bomb :p).

Écrit en Bépo selon l’orthographe de 1990

Perso j’ai pas eu de difficultés particulière alors que j’ai jamais utilisé de langages fonctionnels. Toutes les fonctionnalités de Rust se marient bien ensemble (en tout cas pour ce qu’on a présenté dans la dépêche).

Écrit en Bépo selon l’orthographe de 1990

J’ai écris pas mal de code Rust (enfin pas mal de petits trucs simples pour tester le langage, mais quand même), et ça ne m’a pas du tout gêné. J’ai au contraire beaucoup apprécié le fait que par défaut mes variables soient non-mutables et mes méthodes n’affectent pas l’objet, c’est vraiment génial parce qu’on met vraiment en mut uniquement ce dont on a besoin.

Écrit en Bépo selon l’orthographe de 1990

En effet, je parlais plutôt du passé, ça n'est sans doute pas assez clair dans la dépêche, et j'en suis désolé.

Si un gentil modérateur pouvait préciser ça clairement, ça serais sympa. ^^

Écrit en Bépo selon l’orthographe de 1990