Rust 1.3 est maintenant disponible en version stable
Le langage de programmation de Mozilla améliore de 30% le temps de compilation
Le 2015-09-18 21:28:29, par Malick, Community Manager
Toujours fidèle au cycle de développement rapide de son langage de programmation baptisé Rust, la fondation Mozilla a annoncé, dans un billet de blog, la sortie de Rust 1.3 en version stable.
Rappelons que Rust est un langage de programmation compilé, orienté objet, fonctionnel et procédural. Il est inspiré des langages fonctionnels comme Haskell et ML, du langage orienté objet C++ etc. et a comme principal objectif le développement de systèmes fiables et efficaces avec une grande facilité.
La sortie de Rust 1.3 intervient un peu plus de deux mois après l'annonce de Rust 1.1 et un mois après la disponibilité de Rust 1.2.
Rust 1.3 est livré avec un nouveau livre dénommé The Rustonomicon :The Dark Arts of Advanced and Unsafe Rust Programming . Ce livre traiterait l'essentiel des éléments relatifs à la sécurité qu'il est indispensable de comprendre pour écrire des programmes corrects.
Selon la fondation Mozilla, Rust 1.3 apporte de nouvelles fonctionnalités parmi lesquelles nous pouvons citer :
- au niveau de la bibliothèque avant, une amélioration de la stabilité de l'API incluant une nouvelle durée et une amélioration de l'interface des erreurs Hash/Hasher ;
- l'utilisation d'un algorithme plus efficace par l'adaptateur de chaîne ;
- des améliorations à remplissage zéro afin d'accélérer Vec::resize et Read::read_to_end ;
- l'implémentation de Read::read_to_end a été spécialement réalisée pour stdin and File résultant des accélérations supplémentaires ;
- l'implémentation du PartialEq est maintenant beaucoup plus rapide.
Les développeurs avaient aussi soutenu que Rust 1.3 accorde une place importante à l’optimisation des performances. Ceci étant, ce langage offre une prise en charge préliminaire de Windows XP. Les développeurs avaient également affirmé qu'ils ne voulaient pas traiter Windows XP comme une plateforme de premier niveau, et qu'il est maintenant possible de compiler le code Rust pour Windows XP aussi longtemps que certaines parties de la bibliothèque standard seront évitées.
Rust 1.3 a été développé avec la collaboration de 131 développeurs à travers le monde et la version stable est disponible en téléchargement ici.
Source : blog Rust
Et vous ?
-
UtherExpert éminent séniorCe point de l'article est très confus.
L'outil standard pour construire les projets en Rust existe déjà et marche très bien : c'est Cargo et il était déjà disponible quelque mois avant la sortie de la version 1.0 de Rust. Depuis que Rust est officiellement disponible, Cargo a toujours été l'outil privilégié pour construire et gérer les dépendances des applications et des bibliothèques écrites en Rust.
Le problème est juste au niveau de la compilation du compilateur Rust lui même. Il a été réécrit en Rust (la première version était en OCaml), des années avant l'arrivée de Cargo, le système de construction a donc été basé sur les makefiles. Le compilateur étant assez complexe, l'adapter pour utiliser Cargo est un très gros travail qui n'était pas considéré comme prioritaire et n'a donc réellement commencé que récemment. Il n'y a pas de nouvel outil : Il s'agit juste de mettre a jour le compilateur pour utiliser l'outil standard que quasiment tous les autres projets Rust utilisent déjà.le 17/04/2016 à 9:49 -
SongbirdMembre expert
Je ne doutes pas que je finirais par en faire,
mais aujourd'hui à cet instant, la chose n'est pas évidente pour moi
et je préfère encore me tourner vers d'autres langages
partageant certains points commun avec celui ci.
Concernant la syntaxe, c'est précisément ce qui me donne envie d'étudier Rust (si l'on ne parle que d'elle), car la syntaxe me semble moins... éparpillée que le C++. Cela reste très personnel, bien entendu.
D'ailleurs, si quelque chose te rebute dans la syntaxe, des ressources existent pour expliquer littéralement ce que signifie telle ou telle expression.
Très bonne journée !le 10/06/2017 à 18:41 -
matthiusInactifL'utilisation d'un "=>" pour le match du case, anciennement ":" pour le C peut sembler fastidieuse à l'utilisation, donc inutile.
Mais cela permet peut-être de mieux trouver les erreurs pour le développeur. Est-ce vrai ?
L'intérêt par rapport au Pascal semble donc le temps gagné, si c'est le cas, une jolie présentation, l'utilisation facilitée des objets dans les boucles.le 20/09/2015 à 19:24 -
UtherExpert éminent séniorLe ":" sert déjà à annoter le type en Rust, donc il n'aurait pas vraiment été adapté au match. Utiliser deux caractères par élément de match, c'est vraiment pas ce que j'appelle de la lourdeur. D'ailleurs la syntaxe reste quand même plus légère que celle du C vu que l'on a pas à mettre "case" à chaque élément. De plus le fait que le match utilise le pattern matching permet également de simplifier pas mal de cas qui seraient beaucoup plus complexes en C.
Le "match" a moins de risque d'erreur que le "switch" en C, mais ce n'est pas à cause du "=>". C'est surtout du au fait que le "match" se doit d'être exhaustif : si un match ne capture pas tous les cas possibles, le programme refusera de compiler. De plus le fait que l'on utilise des blocs et pas, comme en C, une suite d’instruction qu'il faut généralement terminer par un break permet de diminuer le risque d'erreur.le 21/09/2015 à 7:41 -
_skipExpert éminentJe suis ce projet depuis ses débuts, je suis plutôt bien disposé à l'idée d'avoir un langage "moderne" positionné quelque part entre java et C++.
Si quelqu'un a des retours sur un usage en production ou même un projet interne, je suis preneur.le 21/09/2015 à 11:01 -
mh-cbonMembre extrêmement actifRust c'est tout de même plusieurs choses, amha.
Un langage pour répondre aux problèmes de ces prédécesseurs.
Un toolset autour du langage pour vivre avec.
Un esprit définitivement progressiste et tourné vers l'avenir.
De cet ensemble, je suis très satisfait,
c'est un changement appréciable car il est plus proche des utilisateurs,
en comparaison, pendant longtemps les avancées que l'on pouvait lire à propos des langages
concernaient des questions très théorique de la théorie des langages (preuves formelles etc)
qui finalement aboutissaient à peu de changement concret/applicable pour l'utilisateur final lambda.
J'apprécie beaucoup cela, pour autant est ce que j'aime ce langage,
bein pas trop en fait,
comme tout le monde, j'aime bien sa théorie et sa mise en pratique,
mmmmmeeeeehhhhhh
la syntaxe est bien trop complexe pour mon goût personnel.
Je ne doutes pas que je finirais par en faire,
mais aujourd'hui à cet instant, la chose n'est pas évidente pour moi
et je préfère encore me tourner vers d'autres langages
partageant certains points commun avec celui ci.le 10/06/2017 à 12:08 -
imperioMembre éméritela syntaxe est bien trop complexe pour mon goût personnel.le 10/06/2017 à 13:56
-
mothsARTMembre régulierMh-cbon : ton approche top => bottom est bonne : beaucoup ne font pas l'effort et du coup progresse peu à mon sens.
Le passage à un typage fort est douloureux mais au final nécessaire car le gain est juste énorme : tu évites une paire de bug à l’exécution, le code est plus cohérent, t'as de meilleurs perfs etc.
Tu mets C et C++ dans le panier des vieux langages mais tu remarqueras que Go ne les remplace pas vraiment car il utilise un Garbage collector et une VM.
Pour moi, Go est un Java bis avec une syntaxe minimaliste, des gros avantages sur la programmation concurrente et des temps de compilation plus court.
Bref, rien de bien novateur à mon sens.
La réalité est que C et C++ sont pour l'instant encore indétrônable dans tous les domaines ou les perfs et la gestion de la mémoire sont critiques.
Rust étant plus ambitieux et par conséquent plus complexe est un réel candidat pour les remplacer.
Je dirais, pour ma part que le cap à passer pour Rust n'était pas vraiment la syntaxe (que je trouve élégante et intuitive) mais plus le borrowing. (et dans une moindre mesure les macros et closures)
Mais, comme tous les langages, il a des zones implicites qui nécessite apprentissage.
Ton exemple et ton incompréhension proviennent de là :
* la variable "f" et "let mut f" : f est dans un premier temps immutable : si le match réussi (passe par le Ok), cette variable est écrasé par le résultat et est converti en une variable mutable.
* le type Result est un peu particulier : il attend soit un objet succès ("Ok"avec le résultat (ici typé en String car on désire récupérer le contenu du fichier mais ça pourrais être n'importe quoi d'autre dans un autre contexte) ou un objet d'échec ("Err" .
* le premier match (qui vérifie l'accès en lecture du fichier) a un retour explicite qui précise que si il détecte une erreur, il sort directement de la fonction (et par conséquent la variable mutable f n'est pas alimenté, la variable s n'est pas créé et le dernier match non executé.
* let permet de déclarer une variable, je ne vois pas trop ce qui te choques. (tu remplaces "var" par "let" dans ton passage de Go à Rust ou de NodeJS à Rust)
* en rust si la dernière ligne d'une fonction ne se termine pas par ";", on retourne implicitement le résultat.
C'est ce qui se passe dans le dernier match.
* s n'est pas déclaré 2 fois, elle est passé par référence dans la fonction "read_to_string".
* read_username_from_file renvoi une valeur qui peut parfaitement être mutable ou non selon la déclaration de ta variable de récupération :
Code : 1
2
3
4let username_immutable = read_username_from_file(); // ou let mut username_mutable = read_username_from_file();
le 11/06/2017 à 14:13 -
UtherExpert éminent séniorResult est un cas particulier vu que comme c'est un élément central du langage, ses variant OK et Err sont inclus dans le prélude, ce qui fait que l'on peut les utiliser directement. Comme le type Result est utilisé partout, n'importe qui avec un minimum d'expérience dans le langage reconnais ça du premier abord.
Cependant, si tu tient à ce que ce soit clair que Ok et Err sont des variants du type énuméré Result, tu peux faire :
Code Rust : 1
2
3
4let mut f = match f { Result::Ok(file) => file, Result::Err(e) => return Result::Err(e), };
le 12/06/2017 à 13:18 -
SongbirdMembre expert
Tout comme les variantes de l'enum Option<T>: Some(T) et None sont parfaitement comprises par le compilateur.
Sans expliciter la provenance des variantes ça donne:Code Rust : 1
2
3
4
5
6
7
8fn main() { let foo = Some("Hello there!".to_owned()); let bar = match foo{ Some(content) => content, None => "Nothing, here.".to_owned(), }; println!("bar={}", &bar); }
Ce sont de petites subtilités, mais vraiment rien d'insurmontable. Ce ne sont pas des ressources "magiques", juste des raccourcis.le 12/06/2017 à 18:09