Rust

原文连接

Vous pouvez l'essayer en ligne

Comparatifs impliquant ce langage

Auteur : Graydon Hoare et Aaron Turon

Langage multiparadigmatique, axé sur la concurrence et sur la sécurité. Cousin de Go.

• http://wiki.github.com/graydon/rust/
• http://wiki.github.com/graydon/rust/language-faq
• https://doc.rust-lang.org/book/
• Diverses ressources pour Rust, colligées par Harris Brakmic : https://rust.zeef.com/harris.brakmic
• Textes d'introduction :
  • une brève introduction à Rust, proposée en 2012: http://winningraceconditions.blogspot.ca/2012/09/rust-1-primer.html
  • une « introduction amicale » à Rust, par Tim Chevalier en 2013: http://catamorphism.org/Writing/Rust-Tutorial-tjc.pdf
  • une semaine avec Rust, texte d'opinion par Karl Matthias en 2013: http://relistan.com/a-week-with-mozilla-rust/
  • en 2013, Neil Brown décrit Rust en mettant l'accent sur ses caractéristiques axées sur la programmation sécuritaire : http://lwn.net/Articles/547145/
  • introduction à Rust par Alex Munroe en 2012: http://me.veekun.com/blog/2012/11/17/a-little-bit-rusty/
  • présentation de Rust par Steve Klabnik, en 2013: http://words.steveklabnik.com/a-30-minute-introduction-to-rust
  • apprendre Rust par exemples, par Jorge Aparicio : http://rustbyexample.github.io/
  • les objectifs du design de C++, selon la prespective de Rust. Un texte de Patrick Walton en 2010: http://pcwalton.blogspot.ca/2010/12/c-design-goals-in-context-of-rust.html
  • apprendre Rust en une trentaine de minutes, texte de 2014: http://doc.rust-lang.org/master/intro.html
  • premiers pas avec Rust, texte de 2014:
    • http://pudgepacket.github.io/rust/2014/07/28/first-taste-of-rust/
    • http://pudgepacket.github.io/rust/2014/08/11/taste-of-rust-pt-2/
  • apprendre Rust en 45 minutes, par Matej Ľach en 2014: http://www.matej-lach.me/rust-basics/
  • en 2014, Prasoon Shukla explique Rust aux débutant(e)s : http://blog.prasoonshukla.com/rust-for-beginners
  • en 2015, Steve Klabnik estime que l'on en est à un bon moment pour apprendre Rust : https://www.codementor.io/learn-programming/now-good-time-learn-rust
  • dans ce texte de 2015, Steve Klabnik offre ce qu'il dit être une « introduction alternative » à Rust : http://words.steveklabnik.com/a-new-introduction-to-rust
  • un premier contact avec Rust :
    • par Evan Miller en 2015: http://www.evanmiller.org/a-taste-of-rust.html
    • par Szmozsánszky István en 2015: https://hacks.mozilla.org/2015/05/diving-into-rust-for-the-first-time/
• http://smallcultfollowing.com/babysteps/blog/categories/rust/
• http://www.readwriteweb.com/hack/2010/11/mozilla-designing-programming-language-rust.php
• http://www.bluishcoder.co.nz/2011/03/31/a-quick-look-at-the-rust-programming-language.html
• http://pcwalton.blogspot.com/2011/04/road-ahead-for-rust.html
• http://dl.dropbox.com/u/4186469/rust-all-hands-w2011.pdf
• Créer un projet avec Rust, texte de 2014: http://hydrocodedesign.com/2014/04/24/practicality-with-rust/
• De nouvelles répétitives for, un texte de Brian Anderson en 2012: http://brson.github.com/rust/2012/04/05/new-for-loops/
• Rust et les pointeurs :
  • un tableau périodique des pointeurs avec Rust, par Kang Seonghoon en 2014: http://cosmic.mearie.org/2014/01/periodic-table-of-rust-types/
  • les pointeurs d'emprunt, conçus spécifiquement pour pointer sur de la mémoire dont ils ne sont pas responsables, un texte intéressant de Nicholas D. Matsakis en 2012: http://smallcultfollowing.com/babysteps/blog/2012/07/17/borrowed-pointer-tutorial/
  • pointeurs sur des entités de taille nulle, texte de 2014 par Nick Hamann : http://www.wabbo.org/blog/2014/03aug_09aug.html
  • emprunt de ressources et durées de vie avec Rust, par Arthur Liao en 2014: http://arthurtw.github.io/2014/11/30/rust-borrow-lifetimes.html
• Réflexion sur la mutabilité héritée avec Rust, qui discute d'intégrer le concept de temps et de changement à travers le temps dans le système de types du langage. Par Nicholas D. Matsakis en 2012: http://smallcultfollowing.com/babysteps/blog/2012/07/24/generalizing-inherited-mutability/
• Une entrevue avec Graydon Hoare, en 2012: http://www.infoq.com/news/2012/08/Interview-Rust
• Les traits avec Rust :
  • texte de Patrick Walton en 2012: http://pcwalton.github.com/blog/2012/08/08/a-gentle-introduction-to-traits-in-rust/
  • raffinements, par Nicholas D. Matsakis en 2012: http://smallcultfollowing.com/babysteps/blog/2012/10/04/refining-traits-slash-impls/
  • texte d'Aaron Turon en 2015: http://blog.rust-lang.org/2015/05/11/traits.html
• Rust et ses « types fantômes », selon Chris Double en 2013: http://bluishcoder.co.nz/2013/08/15/phantom_types_in_rust.html
• Réflexions sur Rust, textes de 2012:
  • à propos de la concurrence : http://winningraceconditions.blogspot.ca/2012/09/rust-1-primer.html
  • à propos de la gestion des erreurs : http://winningraceconditions.blogspot.ca/2012/09/rust-2-linked-task-failure.html
  • les états partagés Type-Safe : http://winningraceconditions.blogspot.ca/2012/09/rust-3-typesafe-shared-state.html
  • les états partagés Type-Safe (suite) : http://winningraceconditions.blogspot.ca/2012/09/rust-4-typesafe-shared-mutable-state.html
  • conclusion de cette série d'articles : http://winningraceconditions.blogspot.ca/2012/09/rust-0-index-and-conclusion.html
  • définir la pureté avec Rust, par Nicholas D. Matsakis en 2012: http://smallcultfollowing.com/babysteps/blog/2012/10/12/extending-the-definition-of-purity-in-rust/
  • types de fonctions et d'objets en Rust, par Nicholas D. Matsakis en 2012: http://smallcultfollowing.com/babysteps/blog/2012/10/23/function-and-object-types/
  • retour sur la pureté de même que sur la « mutabilité » des pointeurs, par Nicholas D. Matsakis en 2012: http://smallcultfollowing.com/babysteps/blog/2012/11/18/imagine-never-hearing-the-phrase-aliasable/
  • qualifier les pointeurs par immuabilité ou par caractéristiques de partage/ de responsabilité? Réflexion de Nicholas D. Matsakis en 2014: http://smallcultfollowing.com/babysteps/blog/2014/05/13/focusing-on-ownership/
  • est-ce que Rust aurait évité un bogue tel que Heartbleed? Opinion de Tony Arcieri en 2015: http://tonyarcieri.com/would-rust-have-prevented-heartbleed-another-look
• Gestion d'erreurs : ../Sujets/Developpement/Pratique-programmation.html#gestion_erreurs_Rust
• Dans ce texte de 2012, Armin Ronacher discute du « ; » en Rust : http://lucumr.pocoo.org/2012/10/18/such-a-little-thing/
• Le langage Rust expliqué aux programmeurs C++ :
  • https://github.com/mozilla/rust/wiki/Rust-for-CXX-programmers
  • série d'articles par Nicholas Cameron :
    • http://featherweightmusings.blogspot.co.nz/2014/04/rust-for-c-programmers-part-1-hello.html
    • http://featherweightmusings.blogspot.co.nz/2014/04/rust-for-c-programmers-part-2-control.html
    • http://featherweightmusings.blogspot.ca/2014/04/rust-for-c-programmers-part-3-primitive.html
    • http://featherweightmusings.blogspot.ca/2014/04/rust-for-c-programmers-part-4-unique.html
    • http://featherweightmusings.blogspot.co.nz/2014/05/rust-for-c-programmers-part-5-borrowed.html
    • http://featherweightmusings.blogspot.co.nz/2014/05/rust-for-c-programmers-part-6-rc-gc-and.html
    • http://featherweightmusings.blogspot.co.nz/2014/05/rust-for-c-programmers-part-7-data-types.html
    • http://featherweightmusings.blogspot.ca/2014/07/rust-for-c-programmers-part-8.html
  • particularités de la gestion de la mémoire avec Rust, qui permettent d'y faire des trucs qui seraient dangereux avec C++, selon Eric Kidd en 2014: http://www.randomhacks.net/2014/09/19/rust-lifetimes-reckless-cxx/
  • un avant-goût de Rust pour programmeuses et programmeurs C++, par Matt Jeacock en 2014: http://mainisusuallyafunction.blogspot.ca/2014/10/a-taste-of-rust-yum-for-cc-programmers_29.html
• Le langage Rust expliqué aux adeptes de la programmation fonctionnelle :
  • texte de Raphael Poss en 2014: http://science.raphael.poss.name/rust-for-functional-programmers.html
• Les « types propriétaires » avec Rust, expliqués par Tim Chevalier qui se questionne dans ce texte de 2013 à savoir s'ils en valent la peine : http://tim.dreamwidth.org/1784423.html
• Gestion de la mémoire avec Rust : Gestion-memoire--Liens.html#langage_Rust
• Intégrer du code Rust à un module Ruby, texte de 2013: http://brson.github.com/2013/03/10/embedding-rust-in-ruby/
• La compagnie Samsung se joint à Mozilla pour développer Rust. Texte de Seth Rosenblatt en 2013: http://reviews.cnet.com/8301-3514_7-57577639/samsung-joins-mozillas-quest-for-rust/
• Vitesse d'exécution de programmes Rust :
  • à propos des programmes séquentiels, par Patrick Walton en 2013: http://pcwalton.github.io/blog/2013/04/18/performance-of-sequential-rust-programs/
  • pour un programme spécifique, par Matt Godbolt en 2015: http://xania.org/201505/on-rust-performance (suivi : http://xania.org/201506/rust-second-look)
• En 2013, Graham King explique ce qu'il a appris de Rust : http://www.darkcoding.net/software/rust-what-i-learnt-so-far/
• Raisonner à propos du tas avec Rust, un texte de John Bender en 2013: http://johnbender.us/2013/04/14/reasoning-about-the-heap-in-rust/
• Texte de Tobby McGuire en 2013, portant sur la surcharge d'opérateurs avec Rust : http://maniagnosis.crsr.net/2013/04/operator-overloading-in-rust.html
• En 2013, Tom Lee explique les trait, les structs et les impls en Rust : http://tomlee.co/2013/05/traits-structs-and-impls-in-rust/
• Le type Option et la gestion du concept-même de pointeur nul, par Nick Desaulniers en 2013: http://nickdesaulniers.github.io/blog/2013/05/07/rust-pattern-matching-and-the-option-type/
• Garantir la sécurité de la mémoire, une présentation de Nicholas D. Matsakis en 2013: http://smallcultfollowing.com/babysteps/pubs/2013.07.17-NEU.pdf
• Appeler des fonctions C d'un programme Rust, par Chris Double en 2013: http://bluishcoder.co.nz/2013/08/08/linking_and_calling_rust_functions_from_c.html
• Texte de Linsey Kuper en 2013 sur les « méthodes par défaut » : http://composition.al/blog/2013/08/26/default-methods-and-negative-diffstats/
• Rust et les pointeurs, par Steve Klabnik en 2013: http://words.steveklabnik.com/pointers-in-rust-a-guide
• Responsabilité sur les pointés avec Rust, texte de 2015 par Chris Morgan : http://chrismorgan.info/blog/rust-ownership-the-hard-way.html
• L'expressivité de Rust, relatée par Steve Klabnik en 2013: http://words.steveklabnik.com/rust-is-surprisingly-expressive
• Utiliser Rust pour enseigner la programmation, cas vécu relaté par David Evans en 2013: http://rust-class.org/pages/using-rust-for-an-undergraduate-os-course.html
• En 2013, Brian Anderson annonce la fin des piles segmentées avec Rust : https://mail.mozilla.org/pipermail/rust-dev/2013-November/006314.html
• Démarrer un ordinateur avec Rust, selon Eric Holk en 2013: http://blog.theincredibleholk.org/blog/2013/11/18/booting-to-rust/
• Écrire un compilateur JIT avec Rust, texte de 2014: http://hydrocodedesign.com/2014/01/17/jit-just-in-time-compiler-rust/
• Rust et les entrées/ sorties, par Jeffery Olson en 2014: http://blog.safaribooksonline.com/2014/01/23/file-io-rust/
• Compiler un programme Rust pour l'exécuter sur un GPU, par Eric Holk en 2012: http://blog.theincredibleholk.org/blog/2012/12/05/compiling-rust-for-gpus/
• Rust et les macros, par Damien Radtke en 2014: http://damienradtke.com/using-and-abusing-macros/
• Polymorphisme de haut niveau et Rust, texte de 2014: http://hydrocodedesign.com/2014/04/02/higher-kinded-types/
• Rust et les expressions régulières, texte de 2014 par Andrew Gallant : http://blog.burntsushi.net/rust-regex-syntax-extensions
• Faire en sorte que Rust soit prêt pour le Web : http://arewewebyet.com/
• En 2014, Steve Klabnik affirme que que la documentation de Rust est sur le point de s'améliorer drastiquement... car il s'en occupera personnellement : http://words.steveklabnik.com/rusts-documentation-is-about-to-drastically-improve
• Le sens du mot unsafe de Rust, décrit par Huon Wilson en 2014: http://huonw.github.io/2014/07/24/what-does-rusts-unsafe-mean.html
• Apprendre Rust, par Urban Hafner :
  • les tâches et les messages, textes de 2014:
    • http://bettong.net/2014/07/28/learning-rust-tasks-and-messages-part-1/
    • http://bettong.net/2014/08/01/learning-rust-tasks-and-messages-part-2/
• Selon Nicholas D. Matsakis en 2014, Rust se stabilise et se rapproche d'une version 1 : http://blog.rust-lang.org/2014/09/15/Rust-1.0.html
• En 2014, Armin Ronacher suggère de poser un regard neuf sur Rust : http://lucumr.pocoo.org/2014/10/1/a-fresh-look-at-rust/
• Rust et les macros :
  • texte de Daniel Keep en 2014: https://danielkeep.github.io/quick-intro-to-macros.html
  • guide officiel : http://doc.rust-lang.org/guide-macros.html
• Voir la stabilité comme un livrable à part entière pour Rust, selon Aaron Turon et Niko Matsakis en 2014: http://blog.rust-lang.org/2014/10/30/Stability.html
• Si vous utilisiez proc avec Rust, vaudrait mieux chercher une alternative, selon Nicholas D. Matsakis en 2014: http://smallcultfollowing.com/babysteps/blog/2014/11/26/purging-proc/
• Rust, les collections et la programmation générique, par Alexis Beingessner en 2014: http://cglab.ca/~abeinges/blah/rust-generics-and-collections/
• Démarrer ce système autoréférentiel qu'est Rust, texte d'Aidan Cully en 2014: http://aidancully.blogspot.ca/2014/12/bootstrapping-rust.html
• À la fin de 2014, Aaron Turon annonce l'approche de la version 1.0 de Rust : http://blog.rust-lang.org/2014/12/12/1.0-Timeline.html
• Dans ce texte de 2014, Arthur Liao présente Rust comme un langage « anti sloppy » : http://arthurtw.github.io/2014/12/21/rust-anti-sloppy-programming-language.html
• Structures de données avec Rust, une série de textes par Alexis Beingessner : http://cglab.ca/~abeinges/blah/
• Rust pour les systèmes embarqués. texte de Job Vranish en 2015: http://spin.atomicobject.com/2015/02/20/rust-language-c-embedded/
• Développement de Rust, les priorités maintenant que la version 1.0 a été publiée, selon Nicholas D. Matsakis en 2015: http://internals.rust-lang.org/t/priorities-after-1-0/1901
• En 2015, Felix S. Klock II explique comment combiner le Pattern Matching, la mutation et le mouvement en Rust : http://blog.rust-lang.org/2015/04/17/Enums-match-mutation-and-moves.html
• Résoudre de « petits » problèmes avec Rust, par Huon Wilson en 2015: http://huonw.github.io/blog/2015/04/little-libraries/
• En 2015, Manish Goregaokar décrit ce qui constitue l'une des principales forces de Rust selon lui : http://manishearth.github.io/blog/2015/05/03/where-rust-really-shines/
• Texte de Nicholas D. Matsakis en 2015 sur la force des enum de Rust : http://smallcultfollowing.com/babysteps/blog/2015/05/05/where-rusts-enum-shines/
• Rust et les fermetures, par Huon Wilson en 2015: http://huonw.github.io/blog/2015/05/finding-closure-in-rust/
• Découvrir avec Rust, par Carol Nichols en 2015: http://carol-nichols.com/2015/05/10/rustc-discovery/
• Mieux vaut être immuable, même dans un seul et même thread, par Manish Goregaokar en 2015: http://manishearth.github.io/blog/2015/05/17/the-problem-with-shared-mutability/
• Quelques listes de trucs qu'il vaut mieux savoir à propos de Rust, par Graydon Hoare en 2015: https://graydon2.dreamwidth.org/214016.html
• Rust et le code dangereux, par Alexis Beingessner en 2015: http://cglab.ca/~abeinges/blah/rust-unsafe-intro/
• Écrire un site Web avec Rust, et survivre! Par Stanisław Pitucha en 2015: http://blog.viraptor.info/post/i-wrote-a-website-in-rust-and-lived-to-tell-the-tale
• Trois mois de vécu avec Rust, relatés par Jamie Brandon en 2015: http://scattered-thoughts.net/blog/2015/06/04/three-months-of-rust/
• Un premier contact avec Rust pour Eric Sink en 2015: http://ericsink.com/entries/rust1.html
• Texte de 2015 par Graydon Hoare qui souligne (avec fierté) ce que la version 1 de Rust ne comprend pas : http://graydon2.dreamwidth.org/218040.html
• En 2015, Nicholas Matsakis et Aaron Turon présentent ce qu'ils ont sur la table pour Rust en 2016: http://blog.rust-lang.org/2015/08/14/Next-year.html
• Texte de 2015 par Jamie Brandon, qui relate son impression somme toute fort positive suivant trois mois d'utilisation de Rust : http://scattered-thoughts.net/blog/2015/06/04/three-months-of-rust/
• Écrire un système d'exploitation avec Rust, textes de Philipp Oppermann : http://os.phil-opp.com/
• En 2016, Hermann J. Radtke III explique la nuance entre &str et String: http://hermanradtke.com/2015/05/03/string-vs-str-in-rust-functions.html
• En 2016, Katarzyna Macias expérimente avec Rust et s'écrit un petit jeu de pendu : http://katecpp.github.io/rust-hangman/

Critique :

• En 2014, Alexander Tsvyashchenko décrit les difficultés qu'il a rencontré en intégrant C++ et Rust sur Qt 5 : http://endl.ch/content/cxx2rust-pains-wrapping-c-rust-example-qt5
• Selon Serdar Yegulalp en 2015, il y aurait lieu d'être plus ambitieux avec Rust : http://www.infoworld.com/article/3014274/application-development/mozilla-should-get-more-ambitious-with-rust.html

Outils :

• Iron, un Framework pour faciliter la programmation sur le Web avec Rust : http://ironframework.io/