Rust 程序语言资料-CSDN博客

2019独角兽企业重金招聘Python工程师标准>>>

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 :
- 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/

转载于:https://my.oschina.net/innovation/blog/817347