URL: https://linuxfr.org/news/encore-une-couche-de-rouille-avec-rust-0-11 Title: Encore une couche de rouille avec Rust 0.11 Authors: Collectif olivierweb, Leo, ariasuni, Nils Ratusznik, Nÿco, BAud, Sylvestre Ledru, claudex, tigrou3tac, palm123, thargos, Dareg et Bruno Michel Date: 2014年04月16日T23:06:38+02:00 License: CC By-SA Tags: rust, mozilla, programmation, ubuntu et firefox Score: 53 Rust 0.11 est sorti le [2 juillet 2014](https://mail.mozilla.org/pipermail/rust-dev/2014-July/010655.html) ! Pour rappel, Rust est un langage de programmation système qui vise la performance et la sûreté. Il est développé par Mozilla, en parallèle d'un nouveau moteur de rendu expérimental écrit en Rust, Servo. Rust est open source. Son développement est fait de façon ouverte sur [GitHub](https://github.com/mozilla/rust) et le code source est publié sous double [licence Apache 2.0](http://www.gnu.org/licenses/license-list.html#apache2) et [[licence MIT]]. ![Rust](http://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png) ---- [Site officiel de Rust](http://www.rust-lang.org/) [Annonce de la version 0.11](https://mail.mozilla.org/pipermail/rust-dev/2014-July/010655.html) [Tag `rust` sur Linuxfr (journaux et dépêches sur Rust)](https://linuxfr.org/tags/rust/public) ---- # Rapide présentation de Rust ## Objectifs du langage L’objectif de Rust [est](http://www.infoq.com/news/2012/08/Interview-Rust) d’être un langage pour l’écriture de programmes systèmes, habituellement écrits en C++. Tout comme C++, Rust permet un contrôle explicite de la gestion de la mémoire et d’autres fonctionnalités du système d’exploitation et du matériel, pour écrire des programmes les plus efficaces possibles. Rust diffère cependant de C++ en mettant l’accent sur la sûreté : grâce à un système de types fort et à l’intégration dans ce système de types de nombre d’idiomes de gestion de la mémoire (on y retrouve les sémantiques d’*ownership*, de *move*, mais également des concepts plus innovants comme l’analyse des *lifetimes*), le compilateur est capable de détecter à la compilation un très grand nombre d’erreurs qui en C++ auraient pu mener à des bugs, voire à des failles de sécurité potentielles. En outre, Rust amène également au monde de la programmation système et impérative certaines fonctionnalités récentes issues de la programmation fonctionnelle : types algébriques, filtrage par motif (_pattern matching_), fermetures lexicales (_closures_), etc. En bref, Rust se veut un remplaçant à C++ : moins complexe, plus sûr et plus moderne. Rust étant développé au sein de Mozilla, on peut se demander s’il est prévu que Rust soit utilisé dans FirefoxOS, ce n’est pas encore le cas, bien que des [essais aient été faits](http://www.reddit.com/r/rust/comments/23izqw/pardon_if_repeat_are_there_any_plans_to_allow/). ## Exemple Voilà un exemple d’une implémentation simpliste de `ls` : ```rust use std::os; fn list_dir(path: &Path) { match std::io::fs::walk_dir(path) { // Le chemin donné par l’utilisateur n’est pas valide None => fail!("Unable to retrieve path: {}", path.display()), // Le chemin donné par l’utilisateur est valide, on liste les fichiers dedans Some(dir) => for file in dir { println!("{}", file.display()); } } } fn main() { // On récupère les arguments passé via la ligne de commande let argv = os::args(); // On vérifie que le nombre d’arguments donnés est bien conforme à ce qu’on attend. match argv.len() { // S’il n’y a pas d’argument, on utilise le répertoire courant comme répertoire à traiter 1 => list_dir(&os::getcwd()), // S’il y a un argument, on le considère comme répertoire à traiter. 2 => list_dir(&Path::new(argv[1])), // Sinon, on considère que l’utilisateur tape avec des moufles. _ => { println!("You must specify exactly zero or one path"); os::set_exit_status(1); } } } ``` ## La communauté Rust Rust est développé par Mozilla, qui emploie une équipe à plein temps pour travailler sur le langage, mais aussi par de très nombreux contributeurs : de 51 pour la version [0.1](https://github.com/mozilla/rust/blob/0.1/AUTHORS.txt), 450 pour la [0.10](https://github.com/mozilla/rust/blob/0.10/AUTHORS.txt) à 559 pour cette [dernière version](https://github.com/mozilla/rust/blob/master/AUTHORS.txt). Des statistiques plus détaillées sont disponibles sur le site [RustStat](http://ruststat.youknowone.org/). Plusieurs moyens de communication existent sur Internet : * les canaux IRC Rust sur [irc.mozilla.org](http://irc.mozilla.org/) : * [`#rust`](http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust) — discussion générale ; * [`#rust-gamedev`](http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-gamedev) — développement de jeux ; * [`#rust-internals`](http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-internals) — compilateur et bibliothèques ; * [`#rust-osdev`](http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-osdev) — développement de systèmes d’exploitation ; * [`#rust-fr`](http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-fr) — communauté Rust francophone ; * la communauté Rust sur [Reddit](http://reddit.com/r/rust) ; * sur Twitter, les mots-clés [`#rustlang`](https://twitter.com/search?q=%23Rustlang&src=hash) et les comptes [`@rustlang`](https://twitter.com/rustlang) et [`@rustlang_fr`](https://twitter.com/rustlang_fr) (peu utilisés) ; * le [wiki](http://github.com/mozilla/rust/wiki) ; * un site pour les coréens : http://rust-kr.org/. Rust a aussi des pages sur [Google Plus](https://plus.google.com/communities/115152292505513839896) et sur [Facebook](https://www.facebook.com/rustlang?fref=ts), ainsi qu’un mot-clé [`#rustlang`](https://www.facebook.com/hashtag/rustlang), mais il n’y a pas d’activité particulière dans ces pages ; ce sont des rappels de Reddit. On peut aussi remarquer que désormais LinuxFr.org fait partie de la mouvance avec sa propre étiquette [`rust`](http://linuxfr.org/tags/rust/public) ;) qui permet de retrouver facilement toutes les dépêches et tous les journaux abordant ce sujet. Les échanges se font aussi directement lors d’[évènemements](#Évènements). ## Installation Le tutoriel officiel détaille l’[installation](http://static.rust-lang.org/doc/master/tutorial.html#getting-started) sur les différentes plateformes, cependant il faut aller dans le [wiki](https://github.com/mozilla/rust/wiki/Doc-packages%2C-editors%2C-and-other-tools) pour avoir plus de détails. 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 ad hoc](http://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/%7Ehansjorg/+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. Voici rapidement les commandes à utiliser pour installer la dernière version : ```bash # Sous tout type de Linux 64bits curl -O http://static.rust-lang.org/dist/rust-0.11.0-x86_64-unknown-linux-gnu.tar.gz tar xfz rust-0.11.0-x86_64-unknown-linux-gnu.tar.gz (cd rust-0.11.0-x86_64-unknown-linux-gnu/ && sudo ./install.sh) # Sous Arch, disponible dans les paquets officiels # Sous Gentoo sudo layman -a rust sudo emerge --autounmask =rust-0.11.0 # Sous Ubuntu sudo add-apt-repository ppa:hansjorg/rust sudo apt-get update sudo apt-get install rust-0.11 ``` Pour Fedora, vous pouvez compiler en Rust en regardant [ici](http://dummdida.blogspot.fr/2013/03/a-package-for-rust-mozillas.html) ou [là](http://minhdo.org/posts/2013-07-27-building-rust-on-fedora.html). # Changements du langage De nombreux changements de syntaxe, de sémantique, de bibliothèques sont advenus depuis la dernière version. Par exemple, le développeur de Angolmois a [dénombré les changements](http://www.reddit.com/r/rust/comments/27k979/how_much_of_a_moving_target_is_rust/ci1mdns) qu’il a dû apporter à son code entre chaque version, depuis la 0.6. Moins de changements de code ont été nécessaires entre la 0.10 et la 0.11. ## Syntaxe [Le symbole `~` a été remplacé](https://github.com/rust-lang/rfcs/pull/59) par le type `Box` pour dénoter les *owned boxes*, et par le mot-clé `box` pour l’allocation. De plus, les tableaux `~[T]` et les chaines `~[str]` ont été remplacées respectivement par `Vec` et `String`. Comme il s’agit d’un changement très important et souvent mal compris par la communauté, voici une brève explication : La précédente syntaxe causait de nombreuses confusions, du fait que `~[T]` et `~str` étaient en fait des structures particulières, et non pas de simple pointeurs `~` vers `[T]` ou `str`, ces derniers n’étant pas des types en Rust. Ceci menait à la bizarrerie syntaxique suivante : ```rust // x est de type ~str, une chaîne allouée sur le tas, redimensionnable // du fait qu’elle possède la mémoire pointée // de même, y est de type ~[T], un vecteur redimensionnable alloué sur le tas let x = ~"foo"; let y = ~[1, 2, 3]; // x est de type ~(&'static str), un pointeur vers une zone allouée sur le // tas contenant un pointeur vers une chaîne statique // y est de type ~([T, .. 3]), un pointeur vers une zone allouée sur le tas // contenant un tableau statique à 3 éléments let x = ~("foo"); let y = ~([1, 2, 3]); ``` Les structures `~[T]` et `~str` étaient en fait des structures situées sur la pile, contenant 3 champs : * un pointeur vers une zone mémoire sur le tas ; * la taille de cette zone, ou « capacité » ; * et la partie de cette zone occupée par des données valides, soit la longueur de la chaine ou du tableau. Ces structures implémentent des chaines et des tableaux dits « redimensionnables », car lors d’un ajout, si la capacité n’est plus suffisante, on met à jour le pointeur vers une zone plus grande, et on recopie depuis l’ancienne. Puisque ces structures possèdent leurs données et disposent de sémantiques de déplacement, personne ne possède de pointeur sur l’ancienne zone, qui peut alors être libérée en toute sûreté. La sémantique de Rust étant devenue suffisamment puissante pour permettre d’exprimer ces propriétés sur des types tiers, ces structures ne nécessitent plus en aucun cas d’être intégrées au compilateur, et ont été déplacées vers la bibliothèque standard, sous les noms de `String` et de `Vec`. On peut d’ailleurs noter que `String` n’est qu’une couche d’abstraction sur `Vec` fournissant des méthodes supplémentaires pour garantir que les données sont une chaîne UTF-8 valide. De même, la syntaxe `~` pour représenter un simple pointeur vers le tas possédant la zone pointée (*owned box*, ou *owning pointer*), a été remplacée par `Box` pour désigner le type et par l’expression `box foo` réalisant une allocation dynamique et renvoyant un `Box`. Cette syntaxe n’ayant plus rien en commun avec `String`et `Vec`, il n’y a plus de confusion possible. Si foo est de type `T`, `box foo` renverra toujours un `Box` (équivalent de l’ancien `~T`), de même que `box (foo)`. * `let x = box "foo"; // x est de type Box<&'static str>.` * `let x = box ("foo"); // pareil.` * `let x = box 5; // x est de type Box.` Si l’on désire maintenant utiliser les chaînes et les tableaux redimensionnables, il faut être explicite et utiliser les noms `String` et `Vec` : ```rust // la méthode from_str alloue une zone de mémoire suffisamment grande // et y recopie le contenu d’une autre chaine, ici une chaine statique // foo est de type String let foo = String::from_str("foo"); // from_slice alloue une zone de mémoire suffisamment grande et y recopie // le contenu d’un autre tableau, ici un tableau statique // bar est de type Vec let bar = Vec::from_slice([1, 2, 3]); // on pourrait également utiliser cette version, équivalente, qui utilise // la macro vec!, fournissant une façon pratique d’initialiser des Vec let bar = vec!(1, 2, 3); ``` Cette nouvelle syntaxe montre bien que `String` et `Vec` sont en fait des structures sur la pile référençant une zone mémoire redimensionnable sur le tas. Ces types sont munis d’un destructeur, ce qui garantit qu’ils disposent de déplacement (*move semantics*) et qu’ils possèdent les données pointées. Ceci évite donc la confusion entre ces types et `Box` qui n’ont rien à voir entre eux. Par ailleurs, écrire `let x = ~"foo"` pouvait faire oublier au programmeur qu’il s’agissait d’une opération couteuse. On avait l’impression qu’il suffisait de prendre un pointeur sur une string, alors qu’il faut en fait allouer une zone sur le tas de la bonne taille, puis recopier la chaine. String::from_str est plus explicite, d’autant plus qu’elle est [documentée](http://static.rust-lang.org/doc/master/std/string/struct.String.html#method.from_str), du fait qu’elle soit dans la bibliothèque standard et non une fonctionnalité intégrée au langage. Enfin, bien que `~[]` et `~str` soient encore disponibles pour le moment, ils devraient être supprimés rapidement. Leur utilisation dans la base de code du compilateur et de la bibliothèque standard a déjà été pratiquement supprimée. Notons que le pointeur `@` qui a été placé derrière une _feature gate_ (il devait être activé explicitement pour pouvoir être utilisé) lors de la sortie de rust 0.10 a été lui aussi été complètement supprimé. ## *Unboxed closures* Le système de [fermetures](http://fr.wikipedia.org/wiki/Fermeture_%28informatique%29) (ou *closures*) de Rust a été complètement repensé. Rust offrait actuellement deux types de fermetures : les *stack closures* et les « procédures ». Les *stack closures*, qui capturaient les variables libres depuis leur environnement __par référence__. Ce type de fermetures était très utilisé dans du code Rust, mais du fait qu’elle ne possédaient pas leur environnement, elles n’étaient pas à proprement parler des [valeurs de première classe](http://fr.wikipedia.org/wiki/Objet_de_premi%C3%A8re_classe). En particulier, il n’était possible de renvoyer une clôture sur la pile (*stack closure*) qu’à condition de la lier à une durée de vie (*lifetime*). ```rust // la fonction get_adder prend un entier et renvoie une fermeture // additionnant cet entier (capturé) à un autre passé en argument fn get_adder(x: uint) -> (|uint| -> uint) { // on renvoie une fonction prenant y et renvoyant x + y // x est ici capturé par référence |y| { x + y } } fn main() { let add5 = get_adder(5); let r = add5(3); } ``` Ce code produisait une erreur du *borrow-checker*. Si ce code avait été exécuté, l’appel de add5 aurait tenté d’accéder à x via une référence pointant vers une zone mémoire qui n’est plus valide, x étant détruit à la fin de la fonction `get_adder`. On aurait pu paramétrer les types par des *lifetimes* et passer x à `get_adder` par référence, mais cela n’aurait pas totalement résolu le problème. Il n’aurait en aucun cas été possible d’utiliser add5 en dehors de la portée des variables capturées (ici, x). Les « procédures » (notées `proc`), qui capturaient leur environnement par copie (en effectuant éventuellement un move). Ces fermetures étaient des valeurs de premier ordre, mais elles permettaient ensuite au code de la fermeture d’effectuer un move depuis les variables capturées au moment où la fermeture était exécutée. Ceci permettait à ces fermetures d’utiliser leur environnement de n’importe quelle façon, mais ne permettait de les appeler qu’une seule fois, car leur environnement était « consommé » par l’appel de la fermeture, du fait des moves possibles. ```rust fn get_proc(x: uint) -> (proc(uint) -> uint) { proc(y) { x + y } // x a été capturé par valeur. Si x avait été // doté de move semantics, toute utilisation de // x ici aurait été une erreur car il aurait été // déplacé dans l’environnement de la fermeture } fn main() { let add5 = get_proc(5); let huit = add5(3); // erreur: l’appel de la procédure prend l’environnement par move // rustc détecte ici l’utilisation d’une valeur déplacée et émet // une erreur. Les procs ne sont donc appelables qu’une seule fois let neuf = add5(4); } ``` La proposition des [unboxed closures](https://github.com/rust-lang/rfcs/pull/114) rend le système de fermetures bien plus souple. Toutes les fermetures captureront désormais leur environnement par copie. Les références étant des valeurs comme les autres en Rust, il sera toujours possible de capturer par référence en capturant explicitement une référence plutôt que la variable : ```rust fn get_adder(x: uint) -> (|uint| -> uint) { // x est ici capturé par valeur (copie). Si x avait été // d’un type doté de sémantiques de déplacement, il n’aurait // plus été utilisable autrement que par la fermeture car // il aurait été déplacé vers son environnement, tout comme // dans l’exemple avec proc |y| { x + y } } // il est possible d’obtenir une capture par référence en capturant // explicitement une valeur dont le type est une référence. On fait // alors une copie de la référence // cet exemple reproduira le comportement précédent. La fermeture // est liée à la durée de vie de x fn get_adder_ref(x: uint) -> (|uint| -> uint) { // on crée explicitement une référence let ref_on_x = &x; // la fermeture capture une copie de la référence // et pas une copie de x |y| { *ref_on_x + y } } ``` Les *unboxed closures* seront implémentées comme des objets ayant chacun leur type unique contenant leur environnement. Pour refléter leur capacité à être invoquées comme des fonctions, elles devront maintenant implémenter un trait. Plusieurs traits seront introduits, pour représenter tous les cas possibles d’utilisation. Tout d'abord, `Fn` : au moment de l’appel, le code reçoit son environnement via une référence mutable. La fermeture peut donc muter son environnement, mais ne peut pas effectuer de move depuis l’environnement. La fermeture est donc appelable plusieurs fois. Ce trait reflète les sémantiques d’appel des anciennes *stack closures*, tout en permettant de choisir au moment de la création de la fermeture si la copie se fait par copie ou par référence. `FnShared` est similaire au précédent, à l’exception que la fermeture reçoit une référence immutable sur son environnement. Elle ne peut donc pas le modifier. L’avantage principal de ces fermetures est qu’elles peuvent être échangées de façon sûre entre différentes tâches s’exécutant de façon concurrente, d’où son nom. Enfin, `FnOnce` implémente des sémantiques d’appel des anciennes *procédures* en passant à la fermeture son environnement par valeur. La fermeture peut alors librement effectuer des moves depuis l’environnement, qui est alors consommé. Une fermeture ne pourra être appelée qu’une seule fois via ce trait. La syntaxe des fermetures ne sera donc plus que du sucre syntaxique sur la déclaration d’un type implémentant le trait approprié et la création d’une valeur unique de ce type. Mais il sera également possible de créer à la main de tels objets, et d’implémenter par exemple plusieurs comportements possibles. (à vérifier) Le système de types de Rust ayant connaissance des sémantiques de déplacement, l’implémentation des *unboxed closures* ne requerra pratiquement aucune modification du système de types. Les règles actuelles garantissent déjà le comportement décrit ci-dessus en fonction de la façon dont l’environnement est passé au code de la fermeture lors de l’appel. ## Bibliothèque standard La bibliothèque standard a été découpée en plusieurs petites bibliothèques indépendantes. `libcore`, qui contient les fonctionnalités les plus basiques de la bibliothèque d’exécution (*runtime library*) du langage est ainsi autonome, et peut être utilisée dans des contextes tels que les systèmes d’exploitation ou la programmation embarquée. Rust dispose maintenant d’une [implémentation des expressions rationnelles](https://github.com/BurntSushi/regexp/), inspirée de RE2. Elle a été [intégrée](https://github.com/mozilla/rust/pull/13700) dans la [distribution officielle](https://github.com/mozilla/rust/commit/b8b74847038802caad12e257f5995d90d531c309) en tant que [`libregex`](http://static.rust-lang.org/doc/master/regex/index.html). [`libregex_macros`](http://static.rust-lang.org/doc/master/regex_macros/index.html) fournit une extension de syntaxe, `regex!`, qui permet à `rustc` de compiler les expressions rationnelles en même temps que le reste du code. En vrac, quelques autres modifications notables : * attention ! `test::BenchHarness` a été renommée en `test::Bencher` ; * la définition des vecteurs doit être plus précise : `[1, 2]` n’est plus acceptée, il faut spécifier le type, par exemple ainsi `[1u, 2]` ; * utilisation de `Result` dans les types de retour de l’interface `Serialize` ; * ajout d’une caisse [GraphViz](http://doc.rust-lang.org/graphviz/index.html) ; * [réduction de la taille des exécutables](https://github.com/mozilla/rust/pull/13833) ; * si vous vous demandez ce que Rust et Lovecraft on en commun, allez voir par [ici](https://github.com/mozilla/rust/issues/13871) ; * [première bibliothèque stabilisée](https://twitter.com/pcwalton/status/471520563345620993) pour la version 1.0 : `std::mem`. # Autour du langage Le code du dépôt Rust sur Github (compilateur, bibliothèque standard, tests unitaires et de performance ainsi que les tutoriels) a atteint les 30 000 commits le 25 juin. Voici un florilège des évènements notables : * prise en charge de Windows 64 bits ; * le site [Are we web yet?](http://arewewebyet.com/) * [un rapprochement avec Dart ?](http://www.reddit.com/r/rust/comments/25rcwl/support_cascade_operator_like_dart/) * [refonte de la documentation](https://mail.mozilla.org/pipermail/rust-dev/2014-May/009842.html) ; * nouvelle URL pour la documentation : http://doc.rust-lang.org/ ; * [deux équipes ont choisi Rust](http://blog.helloworldopen.com/post/83402776977/java-is-back-programming-language-trends-in-hwo) dans la compétition [Hello World Open](https://helloworldopen.com/) ; * le code de Rust est désormais hébergé sur [Github](https://github.com/rust-lang/rust) ; * Rust apparait en bonne position dans une [comparaison de performances d’implémentations dans différents langages](http://codegolf.stackexchange.com/questions/26323/how-slow-is-python-really-or-how-fast-is-your-language/26340#26340) ; * enfin, un petit guide pour la [compilation croisée vers ARM](https://gist.github.com/mcpherrinm/11239842). ## Computer Language Benchmarks Game Ce [test de performance](http://shootout.alioth.debian.org/) dont nous avions parlé dans la [précédente dépêche sur Rust](http://linuxfr.org/news/rust-s-oxyde-en-version-0-10#computer-language-benchmark-game) continue d’être mis à jour. Les sources des programmes de test sont en effet inclus dans les sources même de Rust (voir les fichiers [`shoutout-*`](https://github.com/mozilla/rust/tree/master/src/test/bench)). Les instructions [[SIMD]] sont [ajoutées](https://github.com/mozilla/rust/commit/b9e4fcbf04b21c39b5e704a1f24adbfe179f8814) aux tests à l’aide du module `std::unstable::simd`, le test `shootout-mandelbrot` s’exécute ainsi presque [deux fois plus vite](https://github.com/mozilla/rust/pull/14203). Test | ×ばつ | CPU secs | Elapsed secs |Memory KB |Code B | ≈ CPU Load ----------|------:|---------:|----------:|------------:|-------:|-------------------------: Fasta | 1.7 | 4.66| 4.66 | 780 | 1283| 0% - 1% - 1% - 100% Pidigits | 7.2 | 12.48|12.49 | 1,708 | 677| 0% - 1% - 0% - 100% Mandelbrot| 10 | 52.22|52.23 | 780 | 633| 1% - 100% - 0% - 0% http://www.reddit.com/r/rust/comments/27dc75/what_happened_to_the_shootout_benchmarks/ ## Travis-CI Les tests sur Travis-CI utilisant rust-nightly sont restés bloqués à la version du 18 avril. Travis-CI utilise Ubuntu Precise comme environnement et la construction automatique sur Launchpad s’est arrêtée car [la version de gcc est trop ancienne](https://github.com/Hoverbear/rust-rosetta/issues/44). Le script `configure` de Rust ne prenait pas en charge la définition des variables d’environnement `CC`/`CXX` pour changer de version de compilateur. Des correctifs ont été [proposés](https://github.com/mozilla/rust/pull/13823) le 2 mai et intégrés depuis. La construction continue chez Launchpad a repris début juin. ## Cargo [Cargo](https://github.com/carlhuda/cargo) est le nouveau gestionnaire de paquets annoncé le 17 mars. Yehuda Katz et Carl Lerche réalisent son développement. Le 21 juin, le gestionnaire n’est pas encore en version alpha mais [permet](http://www.reddit.com/r/rust/comments/28oblk/cargo_is_now_at_feature_parity_with_cargolite/) de résoudre les dépendances et de les récupérer depuis Git. La version alpha est [publiée](https://mail.mozilla.org/pipermail/rust-dev/2014-June/010569.html) le 23 juin en même temps que le site web associé pour sa documentation : [crates.io](http://crates.io/). Un PPA pour Ubuntu est disponible à [ppa:cmrx64/cargo](https://launchpad.net/~cmrx64/+archive/cargo), pour notamment pouvoir utiliser Cargo sur Travis-CI. ## Servo Servo est un [projet expérimental de Mozilla](http://www.mozilla.org/en-US/research/projects/) visant à construire un moteur de navigateur Web pour la nouvelle génération d’appareils : téléphones portables, processeurs multicœurs et GPU haute-performance, en tirant parti de la sûreté de Rust, et de ses facilités pour exprimer la concurrence. Il est actuellement développé pour Mac OS X et Linux 64 bits. Il a récemment passé avec succès [le test Acid2](https://blog.mozilla.org/research/2014/04/17/another-big-milestone-for-servo-acid2/), comme planifié dans les [objectifs du second trimestre](https://github.com/mozilla/servo/wiki/Roadmap). [Servo: Designing and Implementing a Parallel Browser](http://www.infoq.com/presentations/servo-parallel-browser). # Liens [Notes de version](https://github.com/rust-lang/rust/wiki/Doc-detailed-release-notes#0110-july-2014). ## 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/pipermail/rust-dev/), de [Reddit](http://www.reddit.com/r/rust) ou de [Twitter](https://twitter.com/search?q=%23Rustlang&src=hash), le blog [*This Week in Rust*](http://blog.octayn.net/categories.html#This-Week-in-Rust-ref) fait une synthèse hebdomadaire des nouveautés et actualités autour de Rust : - [05/04](http://cmr.github.io/blog/2014/04/05/this-week-in-rust/) ; - [13/04](http://cmr.github.io/blog/2014/04/13/this-week-in-rust/) ; - [26/04](https://mail.mozilla.org/pipermail/rust-dev/2014-April/009683.html) ; - [05/05](http://blog.octayn.net/blog/2014/05/05/this-week-in-rust/) ; - [11/05](http://blog.octayn.net/blog/2014/05/11/this-week-in-rust-48/) ; - [17/05](http://blog.octayn.net/blog/2014/05/17/this-week-in-rust-49/) ; - [24/05](http://blog.octayn.net/blog/2014/05/24/this-week-in-rust-50/) ; - _This Week in Rust_ devient un site [à part](http://blog.octayn.net/blog/2014/06/09/future-of-twir/) : http://this-week-in-rust.org/ ; - [10/06](http://blog.octayn.net/blog/2014/06/10/this-week-in-rust-51/) ; - [14/06](http://blog.octayn.net/blog/2014/06/14/this-week-in-rust-52/) ; - [22/06](http://blog.octayn.net/blog/2014/06/22/this-week-in-rust-53/) ; - [30/06](http://blog.octayn.net/blog/2014/06/30/this-week-in-rust-54/). ### Meeting Weekly https://github.com/mozilla/rust/wiki/Meetings ## Évènements De nombreux évènements sont organisés autour de Rust. La [rencontre parisienne](http://www.meetup.com/Rust-Paris/) se répète tous les 3^es lundis du mois dans les locaux de Mozilla. - Paris, le 21 avril -- [Rust MeetUp](https://mail.mozilla.org/pipermail/rust-dev/2014-April/009497.html) ; - Londres, du 25 au 28 avril -- [Ludum Dare 29](http://www.ludumdare.com/compo/2014/04/25/bvssvnis-codebase-in-rust-for-ludum-dare/) ; - San Francisco, le 8 mai -- [Rust MeetUp](https://mail.mozilla.org/pipermail/rust-dev/2014-April/009490.html) : vidéos disponibles sur [air.mozilla](https://air.mozilla.org/rust-meetup-may-2014/) : _Testing Rust and Fuzzing compilers_ de John Regehr, _QuickCheck_ de Andrew Gallant et _Testing Hackathon_ de Erick Tryzelaar ; - Paris, le 19 mai -- [Rust MeetUp](https://mail.mozilla.org/pipermail/rust-dev/2014-April/009695.html), sur Servo ; - Pittsburgh, le 19 mai -- [Rust MeetUp](http://www.meetup.com/Pittsburgh-Code-Supply/events/181773312/) : _Code and Supply_ ; - Seattle, le 22 mai -- [Rust MeetUp](https://mail.mozilla.org/pipermail/rust-dev/2014-May/009825.html) ; - Paris, le 16 juin -- [Rust MeetUp](http://www.meetup.com/Rust-Paris/events/184543012/) ; - San Francisco, le 10 juin -- Dinnerup ; - Brooklyn, le 21 juin -- [Rust MeetUp](https://mail.mozilla.org/pipermail/rust-dev/2014-June/010232.html) ; - Pittsburgh, le 23 juin -- [Rust MeetUp](http://www.meetup.com/Pittsburgh-Code-Supply/events/184125612/) : _Code and Supply_ ; - Londres, le 26 juin -- [First Rust MeetUp in London](http://www.meetup.com/Rust-London-User-Group/events/189607902/) : _Awesome Rust_, _Servo: the parallel browser engine_ ; - San Francisco, le 26 juin -- [Rust Meetup](http://www.meetup.com/Rust-Bay-Area/events/171111672/), vidéos disponibles sur [air.mozilla.org](https://air.mozilla.org/rust-meetup-june-2014/) : _Library Ecosystem for Rust Game Development_, _OpenGL and Rust_, _Voyager_, _Reducing VR latency with Rust_ ; - Lisbonne, le 2 juillet -- [Rust MeetUp](https://reps.mozilla.org/e/lisbon-rust-meetup-1/) : _Goals and crash course through the tutorial_ ; - San Francisco, juillet -- Rust Meetup : WebTech ; - Seattle, le 7 juillet -- [Rust MeetUp](https://www.eventbrite.com/e/seattle-mozilla-rust-meetup-tickets-12142932839) ; - Hanovre, le 10 juillet -- [Rust MeetUp](http://blog.thoughtram.io/posts/organizing-hannovers-first-rust-meetup/) ; - Paris, le 21 juillet -- [Rust MeetUp](http://www.meetup.com/Rust-Paris/events/185457042/) ; ## Présentations Il y aura peut-être bientôt [des cours](https://twitter.com/ImYoric/status/474471051028889600) de Programmation Fonctionnelle Système en Rust à Mozilla Paris. * [A More Detailed Tour of the Rust Compiler](http://tomlee.co/2014/04/03/a-more-detailed-tour-of-the-rust-compiler/) * [Rust Me, I’m a Developer](https://speakerdeck.com/gregmalcolm/rust-me-im-a-developer) * [Guaranteeing memory safety in Rust ](https://air.mozilla.org/guaranteeing-memory-safety-in-rust/) de Nicholas Matsakis * [Programmation système robuste avec Rust](http://www.parleys.com/play/5367b4b5e4b0593229b85842/chapter5/about) de Geoffroy Couprie et Clément Delafargue à Devoxx France * [What is Rust for?](http://kukuruku.co/hub/rust/what-is-rust-for) * _Snowmew’s Architecture_ : [Part 1](http://csherratt.github.io/csherratt/blog/2014/06/08/snowmews-architecture-part-1/), [Part 2](http://csherratt.github.io/csherratt/blog/2014/06/22/snowmews-architecture-part-2/). Snowmew est un moteur de jeu. ## Tutoriels et documentation - [Getting Rusty](http://pzol.github.io/getting_rusty/) - Une présentation, [proposée par Steve Klabnik](http://words.steveklabnik.com/a-30-minute-introduction-to-rust), a été ajoutée sur le site : [_A 30-minute Introduction to Rust_](http://static.rust-lang.org/doc/master/intro.html). Elle porte sur les points clefs de Rust : la possession des données (*ownership*), la sémantique de déplacement ("move semantics"), et l’emprunt de données (*borrowing*). Steve Klabnik vient par ailleurs [d’être embauché par Mozilla](http://words.steveklabnik.com/rusts-documentation-is-about-to-drastically-improve) pour [six mois](http://www.reddit.com/r/rust/comments/28bew8/rusts_documentation_is_about_to_drastically/ci9aune) afin de contribuer à la documentation à partir du 23 juin. - Nouveau tutoriel [Rust by example](http://rustbyexample.com/) - *Rust for C++ programmers* : - [part 1: Hello world](http://featherweightmusings.blogspot.co.nz/2014/04/rust-for-c-programmers-part-1-hello.html) - [an intermission - why Rust](http://featherweightmusings.blogspot.co.nz/2014/04/rust-for-c-programmers-intermission-why.html) - [part 2: control flow](http://featherweightmusings.blogspot.co.nz/2014/04/rust-for-c-programmers-part-2-control.html) - [part 3: primitive types and operators](http://featherweightmusings.blogspot.co.nz/2014/04/rust-for-c-programmers-part-3-primitive.html) - [part 4: unique pointers](http://featherweightmusings.blogspot.co.nz/2014/04/rust-for-c-programmers-part-4-unique.html) - [part 5: borrowed references](http://featherweightmusings.blogspot.co.nz/2014/05/rust-for-c-programmers-part-5-borrowed.html) - [part 6: Rc, Gc, and * pointers](http://featherweightmusings.blogspot.co.nz/2014/05/rust-for-c-programmers-part-6-rc-gc-and.html) - [part 7: data types](http://featherweightmusings.blogspot.co.nz/2014/05/rust-for-c-programmers-part-7-data-types.html) - [Rust class](http://rust-class.org/), un cours de système dans lequel Rust est utilisé. - [Practicality With Rust: Setting Up A Project](http://hydrocodedesign.com/2014/04/24/practicality-with-rust/) - La [documentation Rust](https://github.com/indirect/dash-rust) est disponible sur [Dash](http://kapeli.com/dash) (visualiseur de documentation hors-ligne sur Mac). ## Projets - [rust-http va être réécrit](http://chrismorgan.info/blog/introducing-teepee.html) en une boîte à outils pour le développement web : [teepee.rs](http://teepee.rs/). Les réflexions sur sa conception sont partagées sur le blog de Chris Morgan : [_a careful look at the HTTP/1.1 Status-Line_](http://chrismorgan.info/blog/teepee-design-status-line.html), [_My first look at the Status-Line_](http://chrismorgan.info/blog/teepee-design-status-line-take-two.html), [_header representation_](http://chrismorgan.info/blog/teepee-design-header-representation.html). - [rust-rosetta](https://github.com/Hoverbear/rust-rosetta) continue d’implémenter des exemples de [Rosetta Code](http://rosettacode.org/wiki/Reports:Tasks_not_implemented_in_Rust). 89 exemples sont disponibles au 8 juillet. ### Nouveaux projets - [rust-empty](https://github.com/bvssvni/rust-empty), un [[makefile]] basique pour commencer un projet Rust. - [greffon IntelliJ pour la prise en charge de Rust](https://github.com/Vektah/idea-rust). - [Un compte Twitter](https://twitter.com/rustlangtips) a été ouvert pour publier des astuces sur Rust. - Rust est disponible sur site d’entrainement à la programmation [exercism.io](https://mail.mozilla.org/pipermail/rust-dev/2014-April/009597.html). - [Godbolt](http://rust.godbolt.org/), un compilateur interactif de code Rust (affiche le code assembleur résultant). - [Un snake pour _GameBoy Advance_](https://github.com/exoticorn/gba-rust), il est probable que d’autres jeux très basiques suivront. - [ClearCrypt](http://clearcrypt.org/), une bibliothèque de chiffrement de transport utilisant CurveCP ou Noise. - [rust-nanomsg](https://github.com/TheHydroImpulse/rust-nanomsg), une bibliothèque pour nanomsg. - Dans Atom, - [atom-racer](https://github.com/edubkendo/atom-racer) ajoute la complétion de code pour Rust dans [Atom](https://atom.io/), l’éditeur de GitHub récemment [libéré](https://github.com/blog/1831-atom-free-and-open-source-for-everyone), en utilisant [Racer](https://github.com/phildawes/racer) et [Autocomplete+](https://github.com/saschagehlich/autocomplete-plus) - [atom-language-rust](https://atom.io/packages/language-rust) ajoute la coloration syntaxique. - [iomrascálaí](https://github.com/ujh/iomrascalai) une IA pour les jeux Go/Weiqi/Baduk. - [criterion.rs](https://github.com/japaric/criterion.rs), une bibliothèque de test de performance traduite de la bibliothèque Haskell _criterion_. - [scheme.rs](https://github.com/olsonjeffery/schemers), une implémentation de Scheme en Rust. - [rspt](https://github.com/mikejsavage/rspt), un moteur de rendu physique utilisant OpenGL 2.1, Licence ??. - [Floor](https://github.com/cburgdorf/Floor), un cadriciel web inspiré de ExpressJS, licence MIT. # Conclusion La liste des améliorations pour cette version de Rust n’est pas bien longue: modification des types `Vector`s, et les `String`s en préparation des types à taille dynamique (_DST_), la suppression de `~` et continuation du découpage de la bibliothèque standard de Rust. Tout cela a nécessité beaucoup de travail de fond, et c’est le signe que Rust gagne en maturité. Côté communauté, on a des développeurs payés par Mozilla et Samsung qui travaillent sur Rust et Servo, des dizaines de nouveaux projets, la prise en charge de Rust dans de plus en plus de logiciels et d’environnements, et une présence sur le web toujours plus importante, Rust semble promis à un bel avenir.

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