URL: https://linuxfr.org/news/rust-s-oxyde-en-version-0-10 Title: Rust s’oxyde en version 0.10 Authors: ariasuni olivierweb, BAud, sebcrozet, tigrou3tac, Leo, Bruno Michel, jcr83, Nÿco, reno, stiffux, bubar🦥 et Ontologia Date: 2014年01月24日T08:59:10+01:00 License: CC By-SA Tags: programmation, mozilla, rust, langage, fosdem et ubuntu Score: 63 Mozilla et la communauté Rust ont annoncé la version 0.10 de Rust le [3 avril](https://mail.mozilla.org/pipermail/rust-dev/2014-April/009387.html). Rust est un langage de programmation développé par Mozilla. La version 0.1 a été [annoncée](http://linuxfr.org/news/sortie-de-la-version-0-1-de-rust) par Mozilla le 20 janvier 2012. Pour découvrir le langage, on peut se référer au [nouveau site web](http://www.rust-lang.org/) sur lequel on peut lire :> Rust est un langage de programmation système qui est extrêmement rapide, empêche presque tous les plantages et élimine les [accès concurrent](http://fr.wikipedia.org/wiki/Situation_de_comp%C3%A9tition). ![Logo de Rust](http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png) Rust se veut donc une alternative à C/C++, comme D et Go, et possède tout comme ces derniers un ramasse-miettes, mais qui est optionnel. Sa syntaxe est proche de celle du C/C++/Java tout en étant beaucoup plus expressif. Sa force est de mélanger les fonctionnalités de différents paradigmes, beaucoup venant du fonctionnel (immuabilité par défaut, modèle objet proche de celui d'Haskell, fermetures, etc). Il met l'accent sur la sûreté d'exécution, notamment grâce à son système élaboré de pointeurs intelligents et son système de types forts, sans sacrifier les performances. Depuis la version 0.9, qui a fait l’objet d’[une dépêche](http://linuxfr.org/news/quelques-nouvelles-sur-rust-a-l-occasion-de-la-0-9), les efforts ont notamment porté au cours des 1500 changements sur la simplification du langage. Le langage Rust n'est pas stabilisé, cela viendra avec la version 1.0. Cette itération de développement a apporté le découpage de la bibliothèque *libextra*, introduit des extensions de syntaxe inter *crate*, amélioré la manipulation des pointeurs avec le trait `Deref` et la gestion des erreurs des entrées/sorties. En dehors du compilateur, cette nouvelle version a vu l'introduction d'un nouveau processus de *RFC* ainsi que la construction quotidienne des installateurs binaires. Des améliorations ont été données à l'infrastructure de tests et aux [scripts de construction](https://github.com/mozilla/rust/pull/12793). Des installeurs sont désormais [disponibles](https://mail.mozilla.org/pipermail/rust-dev/2014-March/009223.html) pour Linux, MacOS et Windows. Même si certains font tourner [Rust sur ARM](http://www.reddit.com/r/rust/comments/21qogc/im_making_a_note_here_huge_embedded_success/), ce n'est pas une architecture proposée dans la documentation. Comme pour les précédentes versions, cette version 0.10 doit être considérée comme une version alpha, appropriée pour les adopteurs précoces et les amateurs de langages. ---- [Site officiel de Rust](http://www.rust-lang.org/) [Dépêche sur Rust 0.8](http://linuxfr.org/news/presentation-de-rust-0-8) [Dépêche sur Rust 0.9](http://linuxfr.org/news/quelques-nouvelles-sur-rust-a-l-occasion-de-la-0-9) ---- # Changements du langage # Vous pouvez consulter les [notes de version officielles](https://github.com/mozilla/rust/wiki/Doc-detailed-release-notes), mais ne vous inquiétez pas, on vous résume tout plus bas. ## Syntaxe ## - [Suppression de `do`](https://github.com/mozilla/rust/issues/10815). Il faut remplacer `do spawn { ... }` par `spawn(proc() { ... })`, - [Paramètres de type par défaut dans les types génériques](https://github.com/mozilla/rust/pull/11217) : il est désormais possible de spécifier un type de paramètre par défaut pour les types génériques (à activer avec un attribut de crate `feature`). ```rust #![feature(default_type_params)] struct Foo { a: T } struct Bar { field1: A, field2: B, field3: C } ``` - Pour l'utilisation de bibliothèque, il faut utiliser `extern crate` au lieu de `extern mod`. - [Suppression du filtrage par motif sur `~str`](https://github.com/mozilla/rust/commit/f079c94f723f8c67319da8c727324b2011d7b36f). Il faut désormais utiliser `as_slice()` : ```rust match s.as_slice() { "a" => do_a(), "b" => do_b(), _ => fail!("autre") } ``` * Déplacement de la macro `debug!` dans la bibliothèque `log`. * Modifications de la syntaxe des attributs de crate. Par exemple, au lieu de `#[license = "MIT/ASL2"];`, il faut utiliser `#![license = "MIT/ASL2"]` (sans point-virgule). * Suppression de `Vec::map()`, il faut utiliser les fonctions anonymes ou `.iter().map()`. * Suppression de `collections::List`. On peut utiliser à la place `Vec` ou `collections::DList` si on veut vraiment une liste chainée. ### Suppression des conditions [Les conditions ont été supprimées](https://github.com/mozilla/rust/pull/12039), cela change donc la façon de [gérer les erreurs d’entrée/sortie](https://mail.mozilla.org/pipermail/rust-dev/2014-February/008505.html). Les conditions permettaient de gérer les erreurs un peu à la manière des exceptions en Java et C++, mais de manière sûre. Néanmoins c’était plus complexe à utiliser, et il était difficile de deviner quand la bibliothèque standard utilisait les `Option`/`Result` ou les conditions pour gérer les erreurs. Dans la plupart des cas, il faut maintenant utiliser le filtrage par motif (*pattern matching*) sur les résultats des opérations. Par exemple, pour supprimer un fichier : ```rust let path = Path::new("chemin/vers/fichier.txt"); match fs::unlink(&path) { Err(e) => fail!("L'ouverture de {:?} a échoué: {}.", path, e), _ => debug!("L'ouverture de {:?} a réussi.", path) } ``` En effet, désormais toutes les opérations d’entrées/sorties renvoient un `IoResult` (qui est un petit alias de type : `type IoResult = Result;`). On peut aussi utiliser la macro `try!`, qui arrêtera immédiatement le programme si la récupération du résultat échoue. Cela donne un code plus court dans les cas où l’arrêt du programme n’est pas un souci/est préférable : ```rust let path = Path::new("chemin/vers/fichier.txt"); let file = try!(fs::unlink(&path)); ``` ### Les traits `Deref` et `DerefMut` Ce sont globalement une surcharge à l’opérateur `*`. Par exemple : ```rust struct Foo { a: int } impl Deref for Foo { fn deref<'a>(&'a self) -> &'a int { &self.a } } let test = Foo { a: 3 }; println!("{}", *test); // affiche « 3 » let borrowed: &int = &*test; // déréférence, mais ne déplace pas println!("{}", *borrowed); ``` Le trait `DerefMut` permet la surcharge de la forme `*test = value;`, ainsi que de prendre une adresse mutable du contenu comme `&mut *test`. Ces deux traits participent à la fonctionnalité d’auto-déréférencement du compilateur, rendant les pointeurs intelligents beaucoup plus faciles à utiliser. C’est une étape très importante, car après la disparation du pointeur `@`, on a commencé à utiliser les alternatives dans la bibliothèque standard qui étaient beaucoup moins pratiques, comme `Rc`. Leur utilisation est maintenant beaucoup moins verbeuse et devient, dans plusieurs cas, transparente. ### Modifications des durées de vie des valeurs temporaires ```rust let slot = RefCell::new(1); *slot.borrow_mut() = 4; println!("{}", *slot.borrow()); ``` Ce code ne compilait pas précédemment car l’information de durée de vie liée de la valeur renvoyée par `slot.borrow_mut()` n’était pas désallouée ; la `slot.borrow()` échouait alors (on ne peut emprunter (_borrow_) plusieurs fois une même variable en Rust). Désormais, l’information de durée de vie liée à une valeur temporaire est désallouée le plus tôt possible, c’est-à-dire ici à la fin de la ligne. ### Modification du traitement des valeurs `static` * Les expressions `static` ne doivent pas être d’un type qui a un destructeur défini par l’utilisateur, * ne doivent pas avoir une valeur qui elle-même requiert un destructeur, * celles qui contiennent un `Unsafe` ne peuvent avoir leur adresse prise, * enfin, les expression `static mut` ne doivent pas avoir de type qui nécessite un destructeur (défini par l’utilisateur ou non). ## Bibliothèque standard ## - La fonction `println` a été déplacée dans le module [`std::io::stdio`](http://static.rust-lang.org/doc/master/std/io/stdio/fn.print.html). Pour l'utiliser il faut la macro `println!` ou insérer `use std::io::stdio::println;`. - Les constantes ont été mises en capitales. - [Amélioration de la vitesse de lancement des _green threads_](https://github.com/mozilla/rust/pull/12172) - Les canaux ont été réécrits. Plutôt que d’utiliser feu `SharedChan`, `Chan` peut maintenant être cloné. - [Réusinage de `collections::list`](https://github.com/mozilla/rust/pull/12348). - Le gestion des fichiers sous Windows a été réécrite et fonctionne désormais. rustc utilise maintenant libnative par défaut. - Il y a désormais [un avertissement lorsqu’une méthode publique a un type privé qui apparait dans sa signature](https://github.com/mozilla/rust/pull/12595). - `std::io::stdout()` et `stderr()` sont maintenant [bufferisés par défaut](https://github.com/mozilla/rust/pull/12630). - On peut maintenant utiliser des [constantes littérales](https://fr.wikiversity.org/wiki/Introduction_au_langage_C/Variables_et_constantes#Les_constantes_litt.C3.A9rales) (les valeurs que l’on trouve directement derrière le `=` lors de l’initialisation d’une variable par exemple) au format hexadécimal flottant avec l’extension de syntaxe `hexfloat!`, par exemple `let a = hexfloat!("0x1.999999999999ap-4");` ou `let b = hexfloat!("-0x1.fffp-4", f32);` (notez les deux façon d’appeler l’extension de syntaxe). - [Les `Hashmap`s utilisent désormais le hachage de robin des bois](https://github.com/mozilla/rust/pull/12081). Voir [ici](http://sebastiansylvan.com/2013/05/08/robin-hood-hashing-should-be-your-default-hash-table-implementation/) pour plus d’informations sur les avantages de cet algorithme. ### Extensions de syntaxe Il est désormais possible de créer des extensions de syntaxe dans une _crate_ et de l’utiliser dans une autre : c’est une limitation très ennuyeuse qui disparait ! Les extensions de syntaxe définies par l’utilisateur sont appelées macros et permettent de faire de la méta-programmation. Elles sont donc un outil puissant et non du sucre syntaxique ! Pour rappel, les extensions de syntaxe sont par exemple utilisées dans `print!` et `println!` pour la syntaxe « à la Python », il y a également des exemples dans la section d’au-dessus et d’en dessous ! ### DST Depuis quelques temps, un travail est en cours pour prendre en charge les [_Dynamically-sized types_ (DST) dans Rust](http://blog.babelmonkeys.de/2014/03/18/dst.html). - `std::vec` a été réécrite (dépréciée un temps au profit de `std::vec_ng`), et `~[T]` a disparu. ### Découpage Afin d'avoir une séparation nette des fonctionnalités entre les modules et de pouvoir n'utiliser que les fonctionnalités nécessaires dans un module, `std` et `extra` sont découpées. On a donc désormais un `std` plus petit, et les modules résultant seront à terme [gérés sur leur propre dépôt](https://github.com/mozilla/rust/pull/11787). La documentation pour ces bibliothèques a ainsi été [séparée](http://static.rust-lang.org/doc/master/index.html#libraries). `libextra` a été supprimée. Ses différentes fonctionnalités ont été séparées en plusieurs _crates_ : * libarena * libcollections (dans laquelle a été migré `std::trie` ainsi que les types `std::HashMap`, `std::HashSet` et `EnumSet`) * libflate * libgetopts * libglob * libnum (contient désormais le trait `Integer`) * libsemver * libserialize (on y trouvera [`serialize::json`](http://static.rust-lang.org/doc/master/serialize/json/enum.Json.html) qui a gagné [une API à la JackonJSON](https://github.com/mozilla/rust/pull/12780)). * libsync (modules de programmation concurrentielle) * libterm * libtest * libtime * libuuid * liburl * libworkcache En outre, deux modules ont été extraits de la `libstd` : * librand * liblog Ces découpages permettent également d’éviter les dépendances circulaires et donc de compiler plus de bibliothèques en parallèle. Cela devrait également améliorer légèrement les temps de compilation. ## Compilateur - [Avertissement pour les `Result` non-utilisés](https://github.com/mozilla/rust/pull/11754#issuecomment-33162923) (désactivé par défaut). - Beaucoup d’options ont été enlevées et ajoutées, notamment [ici](https://github.com/mozilla/rust/commit/c13a929d58c3f866687ccf12cc33b2b59a2e10b8). - [Quelques optimisations sur la taille des binaires générés](https://github.com/mozilla/rust/pull/12616). - Les opérateurs composés (comme `+=`) ne peuvent plus être utilisés avec des variables potentiellement non-initialisées. - Le déréférencement est maintenant surchargeable. C’est une autre partie des changements sur les pointeurs intelligents. Un code tel que `let x = *Rc::new(5)` est maintenant valide. Il y a une _pull request_ complémentaire qui déréférencera automatiquement les pointeurs intelligents lorsque approprié, pour éviter les expressions du type `foo.borrow().get().borrow_mut().get()` (ce qui facilitera l’utilisation des pointeurs de la bibliothèque standard qui remplacent `@` et `@mut`). LLVM aura bientôt un [ramasse-miettes précis](https://en.wikipedia.org/wiki/Garbage_collection_%28computer_science%29#Precise_vs._conservative_and_internal_pointers), [le courriel](http://www.reddit.com/r/rust/comments/1y4w5w/patches_for_precise_gc_to_be_submitted_in_months/) annonce même que l’implémentation arrivera dans quelques mois (« pas dans quelques semaines ni dans quelques années ! »). Cela pourrait fournir une base solide à une implémentation d’un ramasse-miettes dans Rust. ## Plateformes prises en charge Rust fonctionne désormais sous Windows (7, Server 2008 R2) seulement x86, Linux (diverses distributions) ARM, x86 et x86-64, OSX 10.6 ("Snow Leopard") et ultérieurs x86 et x86-64, ainsi que Android. Les procédures d'installation déjà en place pour la version 0.8 (pour Windows, Ubuntu, Arch Linux et Gentoo) décrites dans la [dépêche adhoc](https://linuxfr.org/news/presentation-de-rust-0-8#tester-ou-faire-des-trucs-s%C3%A9rieux-avec-rust) sont toujours valables et ont été mises à jour pour cette version. Dès l'annonce, les paquets pour Ubuntu ont été générés dans le PPA [`hansjorg/rust`](https://launchpad.net/~hansjorg/+archive/rust), une compilation pour Arch est disponible dans le dépôt `[community]` et pour Gentoo, *l'overlay* `rust` contient un *ebuild* pour cette version. Le tutoriel détaille aussi l'[installation](http://static.rust-lang.org/doc/master/tutorial.html#getting-started) sur les différentes plateformes. ## Autres outils - `rustpkg` qui avait été [réécrit pour la version 0.9](https://linuxfr.org/news/quelques-nouvelles-sur-rust-a-l-occasion-de-la-0-9#rustpkg) a été [supprimé](https://github.com/mozilla/rust/commit/25fe2cadb10db1a54cefbd1520708d4397874bc3), les sources avec leur historique et leurs bogues ont été extraites dans un [projet sous GitHub](https://github.com/rustpkg/rustpkg). - [Une réflexion avait été lancée](https://github.com/mozilla/rust/issues/10041) sur la création d'une base de données des projets Rust pour la gestion des dépendances. [0install](http://0install.net/) a reçu [des avis positifs](https://github.com/mozilla/rust/issues/11888). Finalement cette idée ne sera pas retenue. - Un nouveau gestionnaire de paquets [Cargo](https://github.com/carlhuda/cargo) a été [annoncé](https://mail.mozilla.org/pipermail/rust-dev/2014-March/009087.html). Yehuda Katz et Carl Lerche, de Tilde Inc., ont à leur actif le gestionnaire de paquets *Bundler* pour Ruby et vont construire celui de Rust. Yehuda Katz a donné quelques précisions [ici](https://mail.mozilla.org/pipermail/rust-dev/2014-March/009090.html) et [là](https://mail.mozilla.org/pipermail/rust-dev/2014-March/009094.html), en indiquant qu'ils utilisent déjà Rust en production dans leur entreprise. - Les demandes de fusion *pull requests* sur GitHub [subissent désormais certains tests d'intégration automatiques dans Travis CI](https://mail.mozilla.org/pipermail/rust-dev/2014-February/008763.html). - [La coloration syntaxique a été ajoutée dans rustdoc](https://github.com/mozilla/rust/pull/12416). - `rustdoc` teste désormais [tous les blocs de code](https://github.com/mozilla/rust/commit/6667f90292d87271204caeef451cf2a977a80fa4). - Les codes inclus dans la documentation (par exemple dans le tutoriel) [sont maintenant testés](https://gist.github.com/brson/9470739). # Autour du langage Nick Cameron — alias *nrc* — a [rejoint](http://thread.gmane.org/gmane.comp.lang.rust.devel/8431) l'équipe de Mozilla dédiée à Rust, qui compterait désormais 6 personnes (discussion au MozSpace du 25 février). Nick a un doctorat en théorie des langages de programmation du *Imperial College London* (thèse intitulée _Existential Types for Variance - Java Wildcards and Ownership Types_), il travaillait depuis deux ans sur la composition et les graphiques de Gecko. Depuis, [Aaron Turon](https://twitter.com/aaron_turon) a rejoint *Mozilla Research* à San Francisco. Une [douzaine d’employés de Samsung](http://www.fastcolabs.com/3027664/under-the-hood-of-mozillas-new-multi-core-browser-and-the-open-source-language-that-powers-i#rdr_indicator_ac4ce7c016f264968dde4f7336b5b58f) s'occupent d’une autre partie du travail. [Un programme de triage de bugs](http://www.reddit.com/r/rust/comments/1w10ip/bug_triage_program/) a été lancé : si on s’inscrit, on reçoit une liste des plus vieux bugs afin de vérifier qu’ils sont toujours d’actualité, s’il y a des doublons, voire corriger le bug. [La façon dont sont traitées les RFC va évoluer](http://thread.gmane.org/gmane.comp.lang.rust.devel/8897), en effet la maturation du projet et l’activité toujours grandissante autour du langage nécessitaient un processus un peu plus rigoureux pour évaluer et implémenter les fonctionnalités de manière organisée. ## Nouveau site web Le thème du site web de Rust a été mis à jour, avec une présentation plus accrocheuse. On peut désormais télécharger des installateurs pour les plateformes Windows et Mac, et des binaires pour Mac ainsi que GNU/Linux, des versions 0.10 et nocturne. ## Informations techniques Une question a été posée sur Reddit : [quels sont les types d’optimisation possibles en Rust ?](http://www.reddit.com/r/rust/comments/1wtwyp/what_kind_of_optimizations_are_possible_in_rust/) (la plupart n’ayant malheureusement pas encore été implémentés, faute de temps) La non-mutabilité par défaut permet de nombreuses optimisations, par exemple : ```rust fn f(x: &int) { let y = *x; g(); let z = *x; println(z.to_str()); } ``` L’optimiseur peut transformer cela de manière valide en : ```rust fn f(x: &int) { let y = *x; g(); println(y.to_str()); } ``` Et ce quelle que soit l’opération qu’effectue `g();` car ici `x` est non-mutable (rappel : le mot `mut` doit être explicitement utilisé, comme ceci : `fn f(mut x: &int)`). D’autre part, cela permettra aussi de faire des optimisations dans certaines boucles, par exemple en C/C++ : ```c int x = 0; foo(&x); for(int i = 0; i < x; i++) bar(); ``` on ne sait pas si `&x` a été récupéré autre part depuis foo, ou si bar la modifie, on est donc obligé de recharger la valeur de x à chaque tour de boucle. En Rust, le compilateur sait si x a été emprunté ou pas. Remarque : ça n’est pas le plus beau bout de code que vous ayez vu mais il montre bien l’idée. Vous pouvez aussi consulter [une autre discussion à propos d’optimisations](http://www.reddit.com/r/rust/comments/1zvrng/simd_instrinsics_or_compiler_optimizations/). ## Chiffres Depuis la dernière dépêche, Ohloh a mis à jour ses [statistiques sur Rust](https://www.ohloh.net/languages/rust). On peut ainsi voir que le nombre de personnes qui modifient du code Rust est [relativement faible mais augmente](https://www.ohloh.net/languages/compare?l0=rust&measure=contributors&percent=false) ([121 projets](https://www.ohloh.net/languages/rust) dans les projets recensés sur Ohloh). [1428 projets](https://github.com/search?q=language%3Arust&type=Repositories) sont recensés sur GitHub. [Rust est le deuxième dépôt sur Github en nombre de tickets fermés sur l’année 2013](https://mail.mozilla.org/pipermail/rust-dev/2014-February/008548.html), un chiffre très impressionnant qui donne une petite idée de l’énorme travail en cours sur le langage. Espérons que cette année soit au moins aussi fantastique pour Rust ! ### Computer Language Benchmark Game Rust fait son entrée dans le fameux _Computer Language Benchmark Game_. Déjà avec un très bon benchmark, [fasta](http://benchmarksgame.alioth.debian.org/u64/benchmark.php?test=fasta&lang=all&data=u64). En effet, sur ce banc d’essai, Rust est aussi rapide que C++ en prenant moins de mémoire sans « tricher » (utiliser de bloc `unsafe`), contrairement à l’implémentation Haskell par exemple, qui utilise des `unsafeUseAsCString` et `unsafeIndex`. D’autre part, on a aussi un mauvais banc d’essai, [pidigits](http://benchmarksgame.alioth.debian.org/u64/benchmark.php?test=pidigits&lang=all&data=u64) car l’implémentation de Rust, selon un des développeurs, « `extra::bigint` n’est pas tellement optimisé ni maintenu et est très très lent » et malgré un [commit pour améliorer les performances de bigint (×ばつ plus rapide)](https://github.com/mozilla/rust/pull/12209). Il convient néanmoins de préciser que les meilleurs résultats sur ce benchmark sont réalisés par des programmes utilisant [GMP](https://gmplib.org/). Vous pouvez consulter la [comparaison avec le C](http://benchmarksgame.alioth.debian.org/u64/benchmark.php?test=all&lang=gcc&lang2=rust&data=u64) et le [C++ sur X86-64](http://benchmarksgame.alioth.debian.org/u64/benchmark.php?test=all&lang=gpp&lang2=rust&data=u64). En comparant les résultats [sur X86](http://benchmarksgame.alioth.debian.org/u32/benchmark.php?test=all&lang=gpp&lang2=rust&data=u32#faster-programs-measurements), on voit que les écarts sont moindres sur plateforme 64 bits. Rust n’a pas encore été vraiment optimisé (LLVM ne peut notamment pas effectuer certaines optimisations car on doit lui fournir plus d’informations), ce qui explique l’écart de performance encore important avec le C ou le C++, dont les compilateurs ont quand même plusieurs dizaines d’années d’optimisation derrière eux. De plus, la différence de performance avec un code lambda (qui ne sollicite pas de manière intensive la machine comme lors de ces bancs d’essai) est beaucoup plus faible. ## Anecdotes Sur Reddit, plusieurs utilisateurs indiquent [pourquoi ils ont choisi Rust plutôt que d’autres langages](http://www.reddit.com/r/rust/comments/1xsfr5/why_have_you_chosen_rust_over_other_system/). Il a été de nombreuses fois demandé si Rust prendrait en charge les *tail call optimizations*, c’est-à-dire l’optimisation des [récursions terminales](https://fr.wikipedia.org/wiki/R%C3%A9cursion_terminale). C’est une fonctionnalité présente dans les langages fonctionnels, qui transforme l’appel récursif en itération (donc série d’étapes séquentielles) lors de la compilation, ce qui est bien plus performant et sauve de la place sur la pile. [Un courriel envoyé sur la liste de diffusion du projet](https://mail.mozilla.org/pipermail/rust-dev/2013-April/003557.html) explique pourquoi elle ne sera jamais implémentée. Il arrive régulièrement que quelqu’un poste, sur le sous-reddit (sous-partie du site web Reddit) consacré à Rust, un sujet en rapport avec le [jeu Rust](http://playrust.com/), un jeu de survie en développement également, et disponible sur GNU/Linux! (exemples : [ici](http://www.reddit.com/r/rust/comments/1y9cme/what_is_this/), [ici](http://www.reddit.com/r/rust/comments/1yd1ep/xtremegaminq_rust_server/), [ici](http://www.reddit.com/r/rust/comments/1ungia/rust_server_new_g33kzone_community_server/)). Du coup, le sous-Reddit a été renommé récemment (et temporairement?) en _Rust is not a game where naked men murder each other with hatchets_ (« Rust n’est pas un jeu où des hommes nus s’entretuent avec des haches »). ## Servo [Servo](https://github.com/mozilla/servo/) est un moteur de rendu HTML et CSS expérimental développé en Rust par Mozilla, Samsung le porte sur Android et les processeurs ARM. L'objectif est de tester un moteur fortement parallélisé dans tous ses aspects (rendu, mise en page, analyse HTML, lecture d'image) en utilisant les tâches isolées. Mozilla ne prévoit pas de sortie immédiate de Servo, puisque son succès repose sur la finalisation de Rust. Le nom du moteur de rendu vient du robot Tom Servo de la série télévisée américaine [[Mystery Science Theater 3000]]. À noter que les sources de Servo incluent une version figée de Rust. Au 3 avril, c'est la version du 24 février de Rust qui est utilisée. ### Feuille de route Bien qu'il ne soit pas prévu d'intégrer ce moteur dans les projets Mozilla, le projet est avancé et quelques [captures d'écran](http://about-rust.blogspot.de/2014/02/some-pages-in-servo-as-of-2014-02-16.html) ont été publiées. Pour 2014, la [feuille de route](https://github.com/mozilla/servo/wiki/Roadmap) est ambitieuse : - 1er trimestre, pouvoir naviguer sur Wikipédia (passer le test Acid2, gestion des appareils à haute densité de pixels (HiDPI)...), - 2nd trimestre, prendre en charge des applications web simples (passer le test Acid3, gérer le Javascript et Ajax, le webgl...), - 3ème trimestre, ajouter des fonctionnalités et tests architecturaux (TLS/SSL, système de cache, canvas, web animations...), - 4ème trimestre, ajouter une interface (multiprocessus, isolation (_sandboxing_), marques-pages, historiques, témoins (_cookies_), extensions, etc.). En mars, Mozilla a publié [trois nouvelles offres d'emploi](https://careers.mozilla.org/en-US/listings/) pour travailler sur Servo. ### Évolutions - [Revamped parallel layout in Servo](http://pcwalton.github.io/blog/2014/02/25/revamped-parallel-layout-in-servo/) (évolution de l’algorithme concernant le parallélisme). - [Servo passe le test Acid2](http://mozillazine-fr.org/servo-reussit-le-test-acid2/). # Liens # Comme dans les précédentes dépêches, sauf indication contraire, les contenus liés sont en anglais. Et il y en a un nombre certain. ## Notes de version - [Wiki](https://github.com/mozilla/rust/wiki/Doc-detailed-release-notes) - [RELEASES.txt](https://github.com/mozilla/rust/blob/master/RELEASES.txt) ## Récapitulatifs ### This Week in Rust Si vous voulez suivre le mouvement de tout ce qui se passe à propos de Rust sans avoir à lire le détail des [commits](https://github.com/mozilla/rust/commits/master), des annonces sur la [liste de diffusion](https://mail.mozilla.org/listinfo/rust-dev) ou de [Reddit](http://www.reddit.com/r/rust), le blog [*This Week in Rust*](http://cmr.github.io/blog/categories/this-week-in-rust/) fait une synthèse hebdomadaire des nouveautés et actualités autour de Rust : - [18/01](http://cmr.github.io/blog/2014/01/18/this-week-in-rust/) - [26/01](http://cmr.github.io/blog/2014/01/26/this-week-in-rust/) - [01/02](http://cmr.github.io/blog/2014/02/01/this-week-in-rust/) - [09/02](http://cmr.github.io/blog/2014/02/09/this-week-in-rust/) - [15/02](http://cmr.github.io/blog/2014/02/15/this-week-in-rust/) - [23/02](http://cmr.github.io/blog/2014/02/23/this-week-in-rust/) - [02/03](http://cmr.github.io/blog/2014/03/02/this-week-in-rust/) - [11/03](http://cmr.github.io/blog/2014/03/11/this-week-in-rust/) - [15/03](http://cmr.github.io/blog/2014/03/15/this-week-in-rust/) - [24/03](http://cmr.github.io/blog/2014/03/24/this-week-in-rust/) - [29/03](http://cmr.github.io/blog/2014/03/29/this-week-in-rust/) Vous pouvez voir que désormais sont indiqués les nouveaux contributeurs rejoignant le projet, et le moins que l’on puisse dire c’est qu’il y en a beaucoup ! ### Meeting Weekly Les employés de Mozilla se rencontrent (par IRC) chaque mardi à 10h du matin, heure du pacifique (UTC-8). C’est ensuite enregistré sur Etherpad et archivé sur le wiki de Rust (sur Github). * [14/01](https://github.com/mozilla/rust/wiki/Meeting-weekly-2014-01-14) (Friend of the Tree; statics on traits; env pointers; lang freeze; iterator naming; statics; docs on primitives) * [21/01](https://github.com/mozilla/rust/wiki/Meeting-weekly-2014-01-21) (primitive impl lang items; env ptrs; boehm; `fmt::Default`; `foo_opt` => `foo`; `\xNN`; `#[no_mangle]`; `crate_type="lib"`) * [28/01](https://github.com/mozilla/rust/wiki/Meeting-weekly-2014年01月28日) (Friend of the Tree; default type params; allocators; dylib to extra; unused Result warning; attributes; I/O; visit_glue) * [04/02](https://github.com/mozilla/rust/wiki/Meeting-weekly-2014年02月04日) (libprim; operator overloading; using system LLVM) * [11/02](https://github.com/mozilla/rust/wiki/Meeting-weekly-2014年02月11日) (Friend of the Tree; binding in struct patterns; rules on static values; `crate` keyword; pizza; `finally` macro; implicit trait bounds) * [18/02](https://github.com/mozilla/rust/wiki/Meeting-weekly-2014年02月18日) (`if_ok!`, issue numbers in commits, debug assertions, hash trait, vector syntax) * [27/02](https://github.com/mozilla/rust/wiki/Meeting-weekly-2014年02月25日) (Friend of the Tree; `TotalEq`; weak `extern fn`; channel names; relative paths) * [11/03](https://github.com/mozilla/rust/wiki/Meeting-weekly-2014年03月11日) (self argument destructuring; type hints; coercion rules; unsafe ptrs) * [18/03](https://github.com/mozilla/rust/wiki/Meeting-weekly-2014年03月18日) (Friend of the Tree; RFCs; 0.10; documentation; RFC review) ## Évènements - Zurich, mercredi 19 février 2014, 18h30 — [Rencontre avec pour thème « un mois avec Rust »](http://www.meetup.com/Rust-Bay-Area/events/156288462/), - Paris, mardi 25 février, 18h30 à 23h30 — [Rencontre sur Rust au Mozilla Space](http://wiki.mozfr.org/RustMeetUpParis#Rust_MeetUp_Paris_01), - San Francisco, le même jour, 19h00 — [_Cap'n Proto, Macros, and Testing_](http://www.meetup.com/Rust-Bay-Area/events/156288462/), présentation retransmise sur [Air Mozilla](https://air.mozilla.org/rust-meetup-february-2014/). - Londres, le 11 mars — [Rust London MeetUp](http://www.meetup.com/Rust-London-User-Group/). - San Francisco, le 13 mars — *Building an operating system, Parallel layout in Servo, Debugging Rust*, présentations retransmises sur [Air Mozilla](https://air.mozilla.org/rust-meetup-march-2014/). - Milan, jeudi 27 mars, 19h00 — [Rust Hands On](http://www.meetup.com/Rust-lang-Milano/events/168386102/). - Paris, lundi 31 mars, 19h00 à 22h00 — [Seconde rencontre Rust au Mozilla Space](https://reps.mozilla.org/e/meetup-rust-paris-02/), annoncée sur la liste de diffusion [Rust-dev](https://mail.mozilla.org/pipermail/rust-dev/2014-March/009111.html). ## Présentations ## Diaporama et/ou vidéos de présentations concernant Rust. * [Présentation de Geoffroy Couprie](http://www.infoq.com/fr/presentations/about-rust) à [ScalaIO](http://scala.io/) en octobre 2013 retransmise sur [InfoQ](http://www.infoq.com/fr/rust2). * [A Dablerr's adventures in Rust](http://angrylawyer.github.io/a-dabblers-adventures-in-rust/). * [A 30 minute introduction to Rust](http://words.steveklabnik.com/a-30-minute-introduction-to-rust). * [Presentiamo Rust](http://www.meetup.com/Rust-lang-Milano/events/163234682/). * [Felix Klock II on Rust: Concurrency, GCs, Type System](http://www.infoq.com/interviews/klock-rust) (vidéo), aussi disponible sur Vimeo ([Felix Klock II - Rust: Safe Systems Programming with the Fun of FP](http://vimeo.com/85253071)). * [An Introduction + Ruby Extensions in Rust](http://t.co/EaWC8Of4DS) par Yehuda Katz au PDX Ruby. * [Servo: building a parallel web browser — FOSDEM 2014](http://mirrors.dotsrc.org/fosdem/2014/UD2218A/Saturday/Servo_building_a_parallel_web_browser.webm). * [« Courte présentation faite à un petit groupe d’amis »](https://docs.google.com/file/d/0ByD_fA6rkqDcbWtCSWNnOUdMaUk/edit?pli=1). * [Macros in Rust](http://sfackler.github.io/syntax-ext-talk/#/). * [Cap'n Proto, Macros and Testing](https://air.mozilla.org/rust-meetup-february-2014/). * [Présentations données au Mozilla Space à Paris](http://rust-meetup-paris.github.io/Talks/index.html) le 25 février 2014. * [Construire un système d’exploitation en Rust](https://air.mozilla.org/rust-meetup-march-2014/) (sans connaitre Rust ou comment écrire un système d’exploitation). Plus d’informations dans [cet article de blog](http://jvns.ca/blog/2014/03/12/the-rust-os-story/). ## Tutoriels et documentation - [Rust is surprisingly expressive](http://words.steveklabnik.com/rust-is-surprisingly-expressive) (assez vieux, mais jamais publié ici et surtout intéressant) - Safari Books Online Blog - [File IO in Rust](http://blog.safaribooksonline.com/2014/01/23/file-io-rust/) - [Network Communication and Serialization in Rust](http://blog.safaribooksonline.com/2014/01/28/network-communication-serialization-rust/) - [Parameters and Bounds in Rust](http://blog.safaribooksonline.com/2014/01/30/parameters-bounds-rust/) - [Using LLVM From Within Rust](http://hydrocodedesign.com/2014/01/31/llvm-with-rust/) - Getting Rusty - [Converting from strings](http://pzol.github.io/getting_rusty/posts/20140201_converting_from_string/) - [ParamsBuilder](http://pzol.github.io/getting_rusty/posts/20140206_params_builder/) - [HashMap](http://pzol.github.io/getting_rusty/posts/20140203_hashmap/) - [Rust par l’exemple: machine à états sûre en utilisant des types fantômes (_phantom types_)](http://www.reddit.com/r/rust/comments/1xs5ua/rust_by_example_safe_state_machines_using_phantom/) - [Le tableau périodique des types de Rust](http://cosmic.mearie.org/2014/01/periodic-table-of-rust-types/) a été mis à jour. - [Comparaison entre le système de modèles (_templates_) en C++ et les types génériques en Rust](https://gist.github.com/bjz/9220415). - [How To Organize Code in Rust per Object or Function](https://gist.github.com/bvssvni/9343353). - [Une réflexion sur le ramasse-miettes](http://sebastiansylvan.com/2012/12/01/garbage-collection-thoughts/). ## Projets [rust-ci](http://www.rust-ci.org/), le projet indépendant qui liste les projets Rust qui utilisent Travis-CI comme plateforme d'intégration continue, a subi quelques mises à jour : catégorisation des [projets](http://www.rust-ci.org/projects/), envoi de la documentation lors de l'exécution du projet dans Travis-CI. Il y a un projet qui existe depuis un moment mais qui n’a jamais été présenté ici, c’est [un compilateur de Rust vers Javascript](http://bilalhusain.com/rust-lexer/syntax.html). ### Nouveaux projets Voici maintenant la liste des nouveaux projets écrits en Rust. La majorité sont petits et sont très souvent dans un état de développement pas très avancé. En effet, ce sont souvent des projets personnels pour apprendre et tester le langage. - [diffbot-rust-client](https://github.com/diffbot/diffbot-rust-client), développement d'une API [commandée par Diffbot](http://www.reddit.com/r/rust/comments/1wf1pm/diffbot_api_client_library/). - [RustLex](https://github.com/LeoTestard/rustlex), un générateur d'analyseurs lexicaux, à la manière de [Lex](http://en.wikipedia.org/wiki/Lex_(software)), implémenté en Rust et produisant du code Rust via un système d'invocation par extensions de syntaxe. - [rust-hash](https://github.com/Jurily/rust-hash), implémentation de [xxHas](https://code.google.com/p/xxhash/) en Rust. - [rust-lua](https://github.com/kballard/rust-lua). - [rust-rosetta](https://github.com/Hoverbear/rust-rosetta) rassemble des codes pour [RosettaCode](http://rosettacode.org/) — comparaison d'implémentation de tâches dans différents langages —, il reste de [nombreux codes](http://rosettacode.org/wiki/Reports:Tasks_not_implemented_in_Rust) à écrire. - [rs-persistent-datastructures](https://github.com/michaelwoerister/rs-persistent-datastructures), des [structures de données persistantes](https://fr.wikipedia.org/wiki/Structure_de_donn%C3%A9es_persistante) en Rust. - [ruste](https://github.com/redoxide/ruste), prise en charge expérimentale de Rust dans Eclipse. - [rust-gamedev-kit](https://github.com/rlane/rust-gamedev-kit), une compilation des bibliothèques de jeu disponible pour rust au sein d’un seul dépôt git. - [rust-mk](https://github.com/KokaKiwi/rust-mk), un script makefile pour compiler ses programmes un peu comme rustpkg. - [Un clone de tetris en Rust](https://github.com/jankes/tetris1), qui se joue dans le terminal. - [rust-dominion](http://www.reddit.com/r/rust/comments/1ykop6/so_i_wrote_a_dominion_simulator_in_rust_though/), un [jeu de dominion](https://fr.wikipedia.org/wiki/Dominion_%28jeu%29). - [rust-bloom-filter](https://github.com/brianmadden/rust-bloom-filter), un [[filtre de Bloom]]. - [uCTF-rs](https://github.com/adwhit/uCTF-rs), un émulateur/débugueur de [msp430](https://en.wikipedia.org/wiki/TI_MSP430). - [Rust-Sudoku-Solver](https://github.com/aochagavia/Rust-Sudoku-Solver), un solveur de sudoku. - [atom-language-rust](https://github.com/zargony/atom-language-rust), coloration syntaxique pour [Atom](https://atom.io/). - Le [tutoriel Kaléidoscope](http://llvm.org/docs/tutorial/) de LLVM sur comment implémenté un langage avec LLVM a été [porté sur Rust](https://github.com/hobinjk/rusty-kaleidoscope). - [QuickCheck](https://github.com/BurntSushi/quickcheck), permet de tester la robustesse de son code face à des entrées aléatoires. - [Racer](https://github.com/phildawes/racer) (Rust Auto-CompletER) est un utilitaire qui fournit une auto-complétion basique pour les éditeurs et IDE. - [rust-highlight](https://github.com/KokaKiwi/rust-highlight), colore le code Rust pour les formats LaTex, HTML et JSON. - [rust-tabular](https://github.com/arjantop/rust-tabular). - [rust-csv](https://github.com/BurntSushi/rust-csv). - [Experiments with Rust and other languages](http://alan-andrade.github.io/) : *Parallel building*, *Echo TCP server*. - [tcp_echo.rs](https://gist.github.com/sw17ch/9864071). - [Asterisk module](https://github.com/FlaPer87/rust-asterisk-example). ## Futur - [Feuille de route pour Rust 1.0](https://docs.google.com/a/octayn.net/spreadsheet/ccc?key=0AlWBWplsaTZvdGdSdEVzZW1BeDA5dm0zM2FFeW0ySEE&usp=drive_web#gid=0) - [Discussion sur l’implémentation d’héritage de traits (pas prévu pour la 1.0)](https://github.com/mozilla/rust/issues/9912). - [Brouillon des différentes RFC qui pourraient être implémentées avant la 1.0](https://github.com/mozilla/rust/wiki/Meeting-workweek-2014年03月03日). # Conclusion Un énorme réusinage et nettoyage qui permet d’envisager l’avenir de Rust plus sereinement, avec un code plus simple et mieux organisé, mais qui nécessitera encore une fois un peu de boulot pour les projets programmés en Rust.

AltStyle によって変換されたページ (->オリジナル) /