Discussion :

[Hinault Romaric]

Rust 1.1 disponible en version stable avec la bêta de Rust 1.2
le langage de programmation de Mozilla améliore de 32% le temps de compilation

Les développeurs responsables du développement du langage de programmation Rust viennent d’annoncer la publication de la version 1.1, moins d’un mois et demi après la sortie de la première version stable de Rust.

Cette première itération de la branche 1.0 se concentre sur l’amélioration des performances de la plateforme. Rust 1.1 améliore de 32% le temps de compilation par rapport à Rust 1.0 (tel que mesurer par bootstrapping).

Des améliorations ont également été apportées aux messages d’erreurs lors de la compilation. Une grande partie des erreurs de compilation dispose désormais d’explications étendues qui s’affichent lorsqu’on clique sur le drapeau « -- ».

En dehors de ces améliorations, Rust 1.1 apporte de nouvelles fonctionnalités intéressantes, dont :

• la disponibilité en version stable de la nouvelle API « std::fs » : cette fonctionnalité rend stable un grand nombre d’extensions pour les API du système de fichiers. Ce qui permet, par exemple, de compiler le gestionnaire de packages Cargo sur Rust ;
• support de musl : il est désormais possible de cibler musl sur Linux. Les binaires générés de cette façon sont liés statiquement et n’ont aucune dépendance ;
• l’intégration de cargo rustc : cette fonctionnalité permet de générer des packages Cargo en passant un drapeau pour invoquer rustc.

La sortie de cette version s’accompagne de la publication de la bêta de Rust 1.2, conformément au cycle de développement du langage de programmation.

Rust 1.2 bêta est disponible en téléchargement avec ses outils. L’amélioration des performances est également au centre de cette version. Grâce aux optimisations qui ont été apportées à cette dernière, sa vitesse de compilation est améliorée de 30% par rapport à Rust 1.1. La compilation pour Cargo est également plus rapide de 18%.

Le gestionnaire de packages du langage a bénéficié de plusieurs autres améliorations de performances.

Rust 1.2 bêta marque la première étape pour l’intégration de la prise en charge de MSVC (Microsoft Visual C). Selon les développeurs du langage, cela représente un grand pas pour la prise en charge de Windows et rend plus facile la liaison entre le code Rust et le code compilé en utilisant la chaine de compilation native.

Rust 1.2 sera publié en version stable dans six semaines, avec la version bêta de Rust 1.3.

À titre de rappel, Rust est un langage de programmation compilé, multiparadigme (orienté objet, fonctionnel et procédural) qui tire parti des langages fonctionnels comme Haskell et ML, du langage orienté objet C++ et bien plus.

Le but de Mozilla est de mettre à la disposition des développeurs « un langage orienté objet statique, typé, sûr, concurrentiel et efficace ». Selon la fondation Mozilla, il s’agit d’un nouveau langage de programmation visant à rendre plus facile le développement des systèmes fiables et efficaces.

Sur le site du projet, on peut lire en guise d’introduction que « Rust est un langage de programmation système qui fonctionne incroyablement rapidement, empêche presque toutes les erreurs de segmentation, et garantit la sécurité des threads. »

Ce qui rend Rust différent des autres langages de programmation est son système de type, selon Mozilla. Le langage fournit la sécurité et la commodité des langages modernes, tout en maintenant l’efficacité et le contrôle de bas niveau des langages C et C++.

Le langage de Mozilla semble disposer de plusieurs caractéristiques intéressantes. Mais, sont-elles suffisantes pour permettre à celui-ci de s’imposer dans l’écosystème de l’IT ?

Télécharger Rust 1.1 et Rust 1.2 bêta

Source : Blog Rust

Et vous ?

Avez-vous testé le langage de programmation Rust ? Qu’en pensez-vous ?

A-t-il du potentiel pour se faire une place devant les ténors ?

Allez-vous adopter ce langage ?

[Crejak]

Je connaissais le langage depuis la 0.9 (fin 2014) et je m'y suis remis après la sortie de la 1.0. C'est vrai qu'au début j'étais un peu sceptique mais une fois qu'on a compris la logique du compilateur, c'est vraiment un plaisir de l'utiliser. Quand par exemple le slogan dit "empêche presque toutes les erreurs de segmentation", c'est vrai ! Venant des langages C / C++ où les segfaults sont un véritable calvaire, et malheureusement assez fréquentes, Rust permet, en forçant à s'adapter au compilateur, de coder de telle sorte qu'il n'y ait jamais de pointeurs invalides, de buffer overflow... Et c'est vraiment très agréable qu'une fois notre code compilé, on est (quasiment) sûr qu'il ne plantera pas.
Cependant, le fait qu'il soit exigeant n'apporte pas que du bon. La gestion des chaînes de caractères par exemple est particulièrement tordue ^^. Mais encore une fois, quand on a compris comment ça marche, on peut faire de réeles économies de mémoire et de calculs (au prix de quelques heures passées sur la doc ).

A-t-il du potentiel pour se faire une place devant les ténors ?

Je pense que Rust a encore un peu de chemin à faire (beaucoup d'éléments de la bibliothèque standard sont marqués `unstable` par exemple, et le compilateur peut être encore largement optimisé), cependant je trouve que ce langage a un réel potentiel et peut être comparé aux "grands" langages compilés comme le C. Un point important est que Rust est un langage multi-paradigme et permet de coder de plusieurs façons différentes (fonctionnelle, orientée objet avec les traits/enums/structs...).
Un autre éléments valorisant ce langage est la mise à disposition d'outils permettant de compiler et de gérer ses projets simplement. Le logiciel cargo, fourni avec Rust sur le site (il me semble), est en effet un gestionnaire de projet complet. En le couplant avec un éditeur de texte (j'utilise personnellement Atom, sorti en 1.0 très récemment, qui compte déjà plusieurs plugins concernant Rust), on a un environnement de développement multi-plateformes et complet.

Allez-vous adopter ce langage ?

Comme je l'ai dit, j'ai déjà adopté ce langage et il est devenu un de mes outils principaux de développement. Dès que j'ai une idée de projet, un petit `cargo new` et c'est parti ! Alors je ne peux que vous encourager à le tester, d'autant que des tutoriels existent pour démarrer : doc.rust-lang.org/index.html.

[Max Lothaire]

Avez-vous testé le langage de programmation Rust ? Qu’en pensez-vous ?

Je l'ai testé. Certains aspects de la syntaxe m'ont un peu perturbé.
Par exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
fn carre (x: i32) -> i64 
{
    x * x  // sans le ' ; '
}

qui serait une écriture recommandée en lieu et place du traditionnel << return x*x; >> que je trouve plus lisible.

Mais c'est surtout Cargo, l'outil de gestion de projet, que j'apprécie énormément (téléchargement automatique de dépendance, etc)

A-t-il du potentiel pour se faire une place devant les ténors ?

Allez-vous adopter ce langage ?

Ce qui fait le succès des autres langages, notamment le c et le c++, c'est le nombre de bibliothèques et de frameworks existants. (merci de me corriger si j'ai dit une bêtise)
J'attends de voir un ce qu'il y aura comme api graphiques par exemple.

[ParseCoder]

Je n'ai pas encore codé avec ce langage mais il a l'air très intéressant. Il n'y a que les life time que je trouve un peu déroutant. Je n'arrive pas à me rendre compte si cela apporte un supplément de sémantique intéressant lorsqu'on lit le code, ou si ça permet seulement d'aider le compilo au prix d'un alourdissement du code.
Si quelqu'un a pratiqué suffisamment, je suis intéressé par son point de vue.
Merci.

[unoomad]

Je l'ai testé. Certains aspects de la syntaxe m'ont un peu perturbé.
Par exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
fn carre (x: i32) -> i64 
{
    x * x  // sans le ' ; '
}

qui serait une écriture recommandée en lieu et place du traditionnel << return x*x; >> que je trouve plus lisible.

Moi au contraire je préfère sans le return c'est ce que je suis habitué a faire en Ruby chacun ses préférences .

[Uther]

Je l'ai testé. Certains aspects de la syntaxe m'ont un peu perturbé.
Par exemple x * x // sans le ' ; ' qui serait une écriture recommandée en lieu et place du traditionnel return x*x; que je trouve plus lisible.

Le cas que tu cites n'est qu'une conséquence d'une propriété plus générale : touts les blocs qui ne se terminent pas par ";" retournent une valeur. Si cette propriété est déroutante dans les fonction où on a l'habitude de faire "return", elle prend tout son intérêt dans les autres types de blocs comme les "if" ou les closures, ... ou l'on a besoin d'une syntaxe plus légère.

Par exemple cela permet de faire:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
let x = if x>0 {x} else {0};
let mut power= iter.map(|&x| {x * x});

Utiliser "return" dans une fonction est considéré comme tout à fait correct.

[psykokarl]

Le cas que tu cites n'est qu'une conséquence d'une propriété plus générale : touts les blocs qui ne se terminent pas par ";" retournent une valeur. Si cette propriété est déroutante dans les fonction où on a l'habitude de faire "return", elle prend tout son intérêt dans les autres types de blocs comme les "if" ou les closures, ... ou l'on a besoin d'une syntaxe plus légère.

Par exemple cela permet de faire:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
let x = if x>0 {x} else {0};
let mut power= iter.map(|&x| {x * x});

Utiliser "return" dans une fonction est considéré comme tout à fait correct.

Autant le fait d'oublier un ";" me fait redouter un return non désirés (les pires des erreur de programmation sont celles qui sont syntaxiquement correctes...), autant l'avantage sur l’opérateur ternaire dans le cas de if ou de switch me parait évident en terme de lisibilité.
Pour les closures je ne suis pas convaincu, pour peu qu'elle se complexifient. L'idéal étant pour moi étant de garder les return obligatoire pour les fonction. Assez pratique pour retourner une ligne à l'arrache sans avoir a commenter ce qui suit...

[Max Lothaire]

Le cas que tu cites n'est qu'une conséquence d'une propriété plus générale : touts les blocs qui ne se terminent pas par ";" retournent une valeur. Si cette propriété est déroutante dans les fonction où on a l'habitude de faire "return", elle prend tout son intérêt dans les autres types de blocs comme les "if" ou les closures, ... ou l'on a besoin d'une syntaxe plus légère.

Par exemple cela permet de faire:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
let x = if x>0 {x} else {0};
let mut power= iter.map(|&x| {x * x});

Utiliser "return" dans une fonction est considéré comme tout à fait correct.

Je n'y avais pas pensé.
Du coup ça devient plus lisible qu'un

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

x = y==2 ? 4 : 1

Le return fonctionne tout à fait dans les fonctions, mais c'est considéré comme << poor style >> d'après la doc.
Après, ce n'est qu'un détail.

[psykokarl]

Je n'y avais pas pensé.
Du coup ça devient plus lisible qu'un

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

x = y==2 ? 4 : 1

Le return fonctionne tout à fait dans les fonctions, mais c'est considéré comme << poor style >> d'après la doc.
Après, ce n'est qu'un détail.

Si ce n'était que pour l'exemple simple de Uther, l’intérêt vis à vis de l’opérateur ternaire est quasi nul et de mon point de vue, ce n'est pas qu'une question de "poor style" ou de recommandation.

Si on compare

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

x = (x > 20) ? "geant" : (x > 15) ?  "grand" : (x > 10) ? "moyen" : (x > 5) ? "petit" : "minscule"

à

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

x = if (x > 20) "geant" elseif (x > 15) "grand" elseif (x > 10)  "moyen" elseif (x > 5) ? "petit" else "minscule"

Les deux expressions sont aussi faciles à lire mais la seconde est plus facile à manipuler (shunter une condition pour tester le comportement, ajouter une clause, générer du code dynamique)

C'est cette tendance à vouloir imposer un style qui fait que je n'adopterai jamais python en dépit de ses qualités.

A mon avis

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

x = if(rouge) x+=1 if(vert) x+=2 if(bleu) x+=4

dans le cadre d'expression courte

ou

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
x = if(rouge) x+=1 
    if(vert) x+=2 
    if(bleu) x+=4
    ...

dans le cadre d'expression longue

restent plus lisible, plus facilement shuntable que

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
x = if(rouge) x+=1 
        if(vert) x+=2 
            if(bleu) x+=4
                ....

parce que les deux premières me rappellent que je pensais a une variable complexe, calculée via une structure "linéaire" alors que pour la troisième, je ne peux pas savoir si il s'agit d'une variable complexe ou une variable alternative avant de lire le code.

Même délire avec les return

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
if(rouge) /*return*/ x+=1; 
if(vert) return  x+=2; 
if(bleu) return  x+=4;
...
return  x+=32;

De mon point de vue, ce n'est pas qu'une question de style dans le sens pour faire joli. Il y a une recherche d'efficience derrière...

[ParseCoder]

Très franchement je ne crois pas que l'aspect syntaxique d'un langage soit le plus important. C'est important, mais les fonctionnalités du langage le sont encore plus et l'intérêt de Rust est évidemment ailleurs que dans sa syntaxe.

[Uther]

Autant le fait d'oublier un ";" me fait redouter un return non désirés (les pires des erreur de programmation sont celles qui sont syntaxiquement correctes...), autant l'avantage sur l’opérateur ternaire dans le cas de if ou de switch me parait évident en terme de lisibilité.
Pour les closures je ne suis pas convaincu, pour peu qu'elle se complexifient. L'idéal étant pour moi étant de garder les return obligatoire pour les fonction. Assez pratique pour retourner une ligne à l'arrache sans avoir a commenter ce qui suit...

C'est ce que je m'étais aussi dit au début mais en fait il n'y a pas de risque car si on ne met pas le ";" le bloc a pour type celui de la valeur retournée, alors que si on met un ";" le bloc est du type vide.
Si on se trompe on aura une erreur de type parfaitement claire.

Le return fonctionne tout à fait dans les fonctions, mais c'est considéré comme << poor style >> d'après la doc.
Après, ce n'est qu'un détail.

Bizarre, je l'ai peut-être loupé mais il me semblait bien qu'il n'y avait rien de tel dans les guidelines.

Si on compare

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

x = (x > 20) ? "geant" : (x > 15) ?  "grand" : (x > 10) ? "moyen" : (x > 5) ? "petit" : "minscule"

à

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

x = if (x > 20) "geant" elseif (x > 15) "grand" elseif (x > 10)  "moyen" elseif (x > 5) ? "petit" else "minscule"

Les deux expressions sont aussi faciles à lire mais la seconde est plus facile à manipuler (shunter une condition pour tester le comportement, ajouter une clause, générer du code dynamique)

Pour être exact la syntaxe correcte en Rust serait :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

x = if x > 20 {"geant"} else if x > 15 {"grand"} else if x > 10  {"moyen"} else if x > 5 {"petit"} else {"minscule"}

Rust a choisi de rendre les accolades obligatoires, ce qui a rendu les parenthèses inutiles autour de l'expression de test.

[imperio]

@Crejak: Les chaînes de caractères sont bizarres ? Qu'est-ce qui te pose souci au juste ? Le fait d'avoir String et &str ? C'est à peu près le même fonctionnement que Vec<T> et &[T]. 'fin je ne comprends pas ce que tu trouves bizarres.

PS: J'ai écrit un tuto en français dispo sur mon blog (le rustbook est complet mais assez désordonné de mon point de vue).

@Uther: Si je me souviens bien, il est dit de préféré les expressions pures (donc "x" au lieu de "return x;"). Par-contre je n'arrive pas à remettre la main sur l'endroit où j'ai lu ça...

@psykokarl: Le ternaire ne fonctionne pas en Rust donc le problème est réglé. Il n'est pas possible de renvoyer "accidentellement" une expression. Exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
let x = 0;
 
x // donc  notre expression
func(); // et là y a une erreur du coup puisque 'x' n'est pas suivi par ';'

Il faut que l'expression soit la dernière instruction du bloc pour être "renvoyée". Exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
let x = 10;
 
if quelque_chose {
    x + 1
} else {
    x - 1
}

Ou encore :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
match s {
    "une string !" => 0,
    "une autre string !" => 1,
    ss if ss.len() == 2 => 2,
    _ => 3
}

PS: Si certains sont intéressés, des meetups Rust sont organisés tous les mois sur Paris (le prochain sera le 20 Juillet normalement). Il faut juste s'inscrire sur meetup avant. Sinon le channel #rust-fr sur irc.mozilla.org est un bon endroit pour discuter de Rust (et en français ! ^^).

[Crejak]

Les chaînes de caractères sont bizarres ? Qu'est-ce qui te pose souci au juste ? Le fait d'avoir String et &str ? C'est à peu près le même fonctionnement que Vec<T> et &[T]. 'fin je ne comprends pas ce que tu trouves bizarres.

Comme je l'ai dit, je viens des langages C/C++ principalement (j'ai aussi fait du Java et je connais un peu Python). Et dans ces langages, les strings sont gérés principalement par un seul type (*char en C, std::string en C++, etc...). C'est donc pourquoi ce double type (String / &str) m'a dérouté au début. Mais encore une fois, c'est une question d'habitude et une fois compris, connaître la différence et savoir manipuler les 2 permet de faire de réelles optimisations du programme

Si je me souviens bien, il est dit de préféré les expressions pures (donc "x" au lieu de "return x;"). Par-contre je n'arrive pas à remettre la main sur l'endroit où j'ai lu ça...

Ils en parlent un peu ici : doc.rust-lang.org/book/functions.html : "Using a return as the last line of a function works, but is considered poor style". A mon avis cela permet de créer une similarité entre les fonctions et les autres blocs, où un return ne fonctionne pas :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
let positive = if x >= 0 { true } else { false};
 
//la fonction équivalente :
fn is_positive(x: i32) -> bool {
    if x >= 0 {
        true
    } else {
        false
    }
}

L'exemple ci-dessus est un peu idiot car on pourrait faire un simple `let positive = x >= 0` mais c'est pour illustrer ^^

[imperio]

L'exemple ci-dessus est un peu idiot car on pourrait faire un simple `let positive = x >= 0` mais c'est pour illustrer ^^

T'aurais aussi juste pu faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
//la fonction équivalente :
fn is_positive(x: i32) -> bool {
    x >= 0
}

PS: Je t'ai vu passer sur #rust-fr. Pourquoi être parti ?

[Uther]

J'ignorais qu'il y eut un #rust-fr sur l'IRC de Mozilla. J'y passerai peut-être.

[imperio]

@Uther: Il a été ouvert il y a quelques mois de ça (je l'ai découvert en allant à un meetup).

[Crejak]

PS: Je t'ai vu passer sur #rust-fr. Pourquoi être parti ?

Je suis juste passé histoire de voir s'il y avait du monde, je devais partir juste après de toutes façon. Mais j'irais sûrement y faire un tour de temps en temps pour voir ce qui s'y dit

PS : J'ai été voir ton blog sur Rust, il est vraiment clair et bien rédigé (pour ceux qui s'y connaissent en programmation, du moins). Je pense que j'orienterais mes amis dessus quand je les convertirai à Rust ^^

[imperio]

@Crejak: Il y a même un développeur du coeur de Rust qui est sur #rust-fr, si tu viens à un rust-meetup sur Paris tu pourras même le voir en vrai (oooooooh ).

Merci pour ton retour, le tutoriel est cependant loin d'être complet, j'essaie de l'améliorer en fonction des retours.

[Hinault Romaric]

Rust 1.2 disponible en version stable avec la bêta de Rust 1.3
le langage de programmation de Mozilla améliore de 30% le temps de compilation

Fidèle au cycle de développement rapide de son langage de programmation Rust, la fondation Mozilla vient d’annoncer dans un billet de blog la sortie de Rust 1.2.

Pour rappel, Rust est un langage de programmation compilé, multiparadigme (orienté objet, fonctionnel et procédural) qui tire parti des langages fonctionnels comme Haskell et ML, du langage orienté objet C++ et bien plus.

Avec Rust, Mozilla offre la sécurité et la commodité des langages modernes, tout en maintenant l’efficacité et le contrôle de bas niveau des langages C et C++. Le langage de programmation est vu comme une alternative à C/C++, qui s’inspire des éléments qui ont fait leur succès, mais qui offre en plus une meilleure sécurité.

Selon la fondation Mozilla, il s’agit d’un langage de programmation visant à rendre plus facile le développement des systèmes fiables et efficaces. Rust est « orienté objet statique, typé, sûr, concurrentiel et efficace », d’après ses développeurs.

Le langage de programmation a atteint sa première version stable en avril dernier. À partir de cette période, Mozilla a adopté un cycle de développement inspiré du système de canaux utilisé pour Firefox et Chrome. Les évolutions de la plateforme peuvent être suivies au travers des canaux Nightly, Beta et Stable, qui sont mis à jour toutes les six semaines.

De ce fait, Rust 1.2 sort avec la version bêta de Rust 1.3.

Des améliorations de performances sont au centre de cette version. Ses développeurs notent une amélioration de la vitesse de compilation de 30% par rapport à Rust 1.1. La compilation pour Cargo est également plus rapide de 18%.

Rust 1.2 apporte la prise en charge de Parallel codegen, ce qui permet une accélération de 30% lors de l’amorçage sur une machine ayant 4 cœurs. Parallel codegen est particulièrement utile pour les versions debug, car il empêche certaines optimisations.

Le gestionnaire de packages Cargo a bénéficié de plusieurs autres améliorations de performances. Il prend désormais en charge les répertoires cibles partagés. Cela permet un gain de temps non négligeable pour des projets complexes.

Rust 1.2 offre une prise en charge préliminaire de MSVC (Microsoft Visual C). Selon les développeurs du langage, cela représente un grand pas pour la prise en charge de Windows et rend plus facile la liaison entre le code Rust et le code compilé en utilisant la chaine de compilation native.

En ce qui concerne le langage, Rust 1.2 marque l’achèvement du support du type dynamically-sized (DST). Cette fonctionnalité permet l’utilisation des pointeurs intelligents sur des types existants comme [T] et Trait. Les DTS sont des types dont la taille est inconnue du compilateur.

Les développeurs trouveront sur le canal bêta Rust 1.3. Cette version accorde également une place importante à l’optimisation des performances. Elle offre aussi une prise en charge préliminaire de Windows XP. « Bien que nous ne voulons pas traiter Windows XP comme une plateforme de ‘premier niveau’, il est maintenant possible de compiler le code Rust pour Windows XP aussi longtemps que vous évitez certaines parties de la bibliothèque standard », écrivent les développeurs de Rust.

Rust 1.2 a été développé avec la collaboration de 180 développeurs à travers le monde.

Télécharger Rust 1.1 et Rust 1.2 bêta

Source : Blog Rust

[Malick]

Rust 1.3 est maintenant disponible en version stable
le langage de programmation de Mozilla améliore de 30% le temps de compilation

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 ?
Que pensez-vous de cette version stable de Rust 1.3 ?
Allez-vous l'essayer ?