한국어,
Português,
Русский,
+<<<<<<< HEAD
+ Italiano
+=======
Tiếng việt
+>>>>>>> upstream/master
diff --git a/it-IT/community.md b/it-IT/community.md
new file mode 100644
index 000000000..2b3ad2859
--- /dev/null
+++ b/it-IT/community.md
@@ -0,0 +1,245 @@
+---
+layout: it-IT/default
+title: La comunitá di Rust · Il linguaggio di programmazione Rust
+---
+
+# La comunitá di Rust
+
+Il linguaggio di programmazione Rust ha molte qualitá ma la forza piú
+grande di Rust sta nella comunitá di persone che si sono unite per
+rendere il lavorare in Rust un'esperienza appagante.
+
+Noi ci impegniamo a allestire un ambiente amichevole, sicuro
+e accomondante per tutti, a prescindere da sesso, orientamento
+sessuale, disabilitá, etnia, religione o altre caratteristiche
+personali. Il nostro [codice di comportamento][coc] definisce
+gli standard comportamentali in tutti i forum di Rust.
+
+Se sei stato o sei in questo momento vittima di attacchi
+o disturbato da un membro della comunitá, per favore
+[contatta][mod_team_email] qualcuno dal [team di moderazione di Rust]
+[mod_team] immediatamente. Che tu sia un regolare frequentatore o
+un nuovo arrivato, ci impegniamo per rendere la comunitá uno spazio
+sicuro per te.
+
+[coc]: conduct.html
+[mod_team_email]: mailto:rust-mods@rust-lang.org
+
+## Per iniziare
+
+Le risorse piú importanti della comunitá per coloro che sono nuovi a Rust sono:
+
+- [#rust-beginners][beginners_irc], un canale IRC che
+ ama rispondere a domande di qualsiasi difficoltá.
+- Il [Forum Utenti][users_forum], per parlare di tutto
+ ció che riguarda Rust.
+
+Potresti anche trovare aiuto sul sito di domande e risposte [Stack Overflow][stack_overflow].
+
+[stack_overflow]: https://stackoverflow.com/questions/tagged/rust
+
+## Novitá
+
+[This Week in Rust][twir] raccoglie le ultime news, eventi futuri
+e racconta su base settimanale dei cambiamenti in Rust e le
+sue librerie. [Il Blog di Rust][rust_blog] é dove il team di Rust
+annuncia sviluppi importanti del linguaggio. Quasi ogni cosa
+viene discussa anche nel subreddit non ufficiale [/r/rust][reddit].
+
+Siamo anche su [Twitter][twitter].
+Se non conosci l'inglese, puoi anche seguire il nostro [Weibo][weibo] per gli utenti cinesi.
+
+[twir]: https://this-week-in-rust.org/
+[rust_blog]: http://blog.rust-lang.org/
+[reddit]: https://www.reddit.com/r/rust
+[reddit_coc]: https://www.reddit.com/r/rust/comments/2rvrzx/our_code_of_conduct_please_read/
+[twitter]: https://twitter.com/rustlang
+[weibo]: http://weibo.com/u/5616913483
+
+## Canali IRC
+
+I Rustacchiani mantengono un numero di canali [IRC] amichevoli e molto frequentati sulla rete IRC di Mozilla, irc.mozilla.org.
+
+Il canale [#rust][rust_irc] é dedicato alle discussioni
+generali su Rust ed é anche un buon posto per cercare aiuto.
+Troverai persone disposte a rispondere a qualsiasi domanda
+su Rust, tipicamente in poco tempo.
+
+Gli sviluppatori di Rust si organizzano su [#rust-internals][internals_irc]. Dedicato alla discussione continua sulla modifica di Rust stesso. Qui si possono chiedere informazioni su come contribuire a Rust.
+
+### Canali principali
+
+- [#rust][rust_irc] per tutto ció che riguarda Rust
+- [#rust-beginners][beginners_irc] per coloro che sono nuovi al linguaggio, é meno trafficato di #rust
+- [#rust-internals][internals_irc] per discutere sui dettagli di come é fatto Rust e la sua implementazione
+- [#rustc][rustc_irc] dove parla il [team di sviluppo del compilatore][compiler_team]
+- [#rust-libs][libs_irc] dove parla il [team di sviluppo delle librerie][library_team]
+- [#rust-tools][tools_irc] dove parla il [team di sviluppo degli strumenti][tool_team]
+- [#rust-lang][lang_irc] dove parla il [team della sintassi][language_team]
+- [#rust-community][community_irc] dove parla il [team di moderazione][community_team]
+
+### Canali internazionali
+
+- [#rust-br][br_irc] é dedicado à discussão sobre Rust no Brasil
+- [#rust-de][de_irc] ist für die allgemeine Diskussion über Rust auf Deutsch
+- [#rust-es][es_irc] es para una discusión general sobre Rust en español
+- [#rust-fr][fr_irc] est dédié à la programmation en Rust en français
+- [#rust-ru][ru_irc] для общих дискуссий о Rust на русском языке
+
+### Canali specifici
+
+- [#cargo][cargo_irc] per parlare di Cargo, il gestore di pacchetti di Rust
+- [#rust-bots][bots_irc] notifiche su Rust da parte di bot automatici
+- [#rust-docs][docs_irc] dove si parlano i membri del team non ufficiale di documentazione
+- [#rust-crypto][crypto_irc] per discutere della crittografia in Rust
+- [#rust-gamedev][gamedev_irc] per coloro che sviluppano videogiochi in Rust
+- [#rust-networking][networking_irc] per coloro che sviluppano reti di computer con Rust
+- [#rust-offtopic][offtopic_irc] per parlare di cose non correlate a Rust tra Rustacchiani
+- [#rust-osdev][osdev_irc] per lo sviluppo di sistemi operativi in Rust
+- [#rust-webdev][webdev_irc] per coloro che sviluppano applicazioni e server web in Rust
+- [#servo][servo_irc] il canale di Servo, il motore di navigazione scritto in Rust
+
+[IRC]: https://en.wikipedia.org/wiki/Internet_Relay_Chat
+[beginners_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-beginners
+[bots_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-bots
+[br_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-br
+[cargo_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23cargo
+[community_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-community
+[crypto_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-crypto
+[de_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-de
+[es_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-es
+[fr_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-fr
+[gamedev_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-gamedev
+[internals_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-internals
+[lang_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-lang
+[libs_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-libs
+[networking_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-networking
+[offtopic_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-offtopic
+[osdev_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-osdev
+[ru_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-ru
+[rust_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust
+[rustc_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rustc
+[servo_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23servo
+[tools_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-tools
+[webdev_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-webdev
+[docs_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-docs
+
+## Forum di discussione
+
+Abbiamo due forum per le discussioni sul lungo periodo:
+
+- Il [Forum Utenti][users_forum], per fare domande, condividere
+ frammenti di codice, parlare dei progetti in Rust e via dicendo.
+
+- Il [Forum Sviluppo][internals_forum], un luogo dedicato alla discussione
+ del design e dell'implementazione di Rust (includendo Cargo, la libreria standard
+ e altre componenti chiave dell'infrastruttura).
+
+[users_forum]: https://users.rust-lang.org/
+[internals_forum]: https://internals.rust-lang.org/
+
+## Canale YouTube
+
+Rust ha un [Canale YouTube][youtube_channel] dove viene caricato del materiale
+sul linguaggiodi programmazione. Si trovano qui registrazioni di varie conferenze
+tenute da membri della comunitá Rust.
+
+[youtube_channel]: https://www.youtube.com/channel/UCaYhcUwRBNscFNUKTjgPFiA
+
+## Gruppi Utenti e Incontri
+
+Ci sono oltre 50 [Gruppi Utenti Rust][user_group] nel mondo fra oltre 20
+countries che contano oltre 7,000 membri. I Rustacchiani si incontrano periodicamente
+nei Gruppi Utenti Rust.
+Un ottimo modo per entrare nella comunitá, per imparare e per socializzare
+con persone che hanno interessi simili. Gli incontri sono tenuti su base mensile
+e sono molto informali. Gli incontri sono aperti a tutti.
+
+C'é un [calendario][calendar] globale per organizzare gli eventi Rust.
+Contatta il [team di moderazione][community_team] per aggiungere il tuo.
+
+[user_group]: ./user-groups.html
+[calendar]: https://www.google.com/calendar/embed?src=apd9vmbc22egenmtu5l6c5jbfc@group.calendar.google.com
+
+## Il team di Rust
+
+Rust ha un modello di sviluppo guidato dalla comunitá dove la maggior parte
+delle decisioni sono fatte in discussioni aperte e condivise, sotto la
+supervisione di diversi [team][teams]:
+
+* Il [Team Base][core_team] si occupa di guidare il processo di design
+e sviluppo, controllando l'introduzione delle nuove funzionalitá e
+come ultima voce in capitolo per risolvere le controversie per le
+quali non vi é un chiaro consenso(ció succede raramente).
+
+* Il [Team della sintassi][language_team] si occupa di progettare le nuove
+funzionalitá del linguaggio.
+
+* Il [Team delle librerie][library_team] si occupa della libreria standard,
+i pacchetti gestiti da rust-lang e le convenzioni da tenere.
+
+* Il [Team del compilatore][compiler_team] si occupa del funzionamento del
+compilatore e delle ottimizzazioni.
+
+* Il [Team degli strumenti][tool_team] si occupa degli strumenti ufficiali
+come [Cargo], [rustup] e [rustfmt] ma anche della piattaforma di testing e
+rilascio continuo del progetto.
+
+[Cargo]: https://crates.io
+[rustup]: https://www.rustup.rs
+[rustfmt]: https://github.com/rust-lang-nursery/rustfmt
+
+* Il [Team della comunitá][community_team] coordina gli eventi,
+la portata pubblica, l'utilizzo commerciale, il materiale didattico e l'immagine.
+Possono anche rivolgersi direttamente ai membri dell'organizzazione nel caso
+in cui non sia chiaro chi contattare in delle discussioni riguardanti Rust.
+
+* Il [Team di moderazione][mod_team] assicura il rispetto del
+[codice di condotta][coc].
+
+* Il [Team di documentazione][doc_team] si assicura che Rust abbia
+ una documentazione fantastica.
+
+Oltre ai diversi team ufficiali, molti team hanno dei revisori che possono
+verificare del codice. Se volessi entrare a far parte di uno di questi team
+sentiti libero di incontrare un capogruppo o un qualsiasi altro membro in modo
+che ti possa aiutare a partecipare.
+
+[teams]: team.html
+[core_team]: team.html#Core-team
+[language_team]: team.html#Language-design-team
+[library_team]: team.html#Library-team
+[compiler_team]: team.html#Compiler-team
+[tool_team]: team.html#Tooling-and-infrastructure
+[community_team]: team.html#Community-team
+[mod_team]: team.html#Moderation-team
+[doc_team]: team.html#Documentation-team
+
+## Sviluppo di Rust
+
+Rust ha avuto oltre [1'200 diversi sviluppatori][authors], un numero che cresce
+di settimana in settimana. [Vorremmo che tu ti unissi a quella lista][contribute]!
+
+Come menzionato sopra, il [Forum Sviluppo][internals_forum] é dedicato alla discussione
+sul design e implementazione di Rust. Molte discussioni avvengono anche su
+GitHub:
+
+- Nel [repository principale][github] e nella [bacheca problemi][issue_tracking]
+ si svolge il lavoro principale di implementazione. I nostri revisori si impegnano
+ ad essere amichevoli e utili ai nuovi sviluppatori, quindi non esitare a mandare
+ una tua pull request!
+
+- Il [repository per le RFC][rfcs] traccia il nostro processo di Request for Comment,
+ il modo principale in cui la comunitá Rust e il team raggiungono il consenso
+ sulle nuove funzionalitá proposte per il linguaggio, le librerie ufficiali e gli strumenti.
+
+Circa settimanalmente, il team di Rust emana un [rapporto dei team][team_reports]
+che indica su cosa sono impegnati i team, inclusa l'analisi delle RFC e il
+processo di implementazione.
+
+[authors]: https://github.com/rust-lang/rust/blob/88397e092e01b6043b6f65772710dfe0e59056c5/AUTHORS.txt
+[contribute]: contribute.html
+[github]: https://github.com/rust-lang/rust
+[rfcs]: https://github.com/rust-lang/rfcs
+[team_reports]: https://github.com/rust-lang/subteams
+[issue_tracking]: https://github.com/rust-lang/rust/issues
diff --git a/it-IT/conduct.md b/it-IT/conduct.md
new file mode 100644
index 000000000..1a80fb524
--- /dev/null
+++ b/it-IT/conduct.md
@@ -0,0 +1,40 @@
+---
+layout: it-IT/default
+title: Il codice di comportamento di Rust · Il linguaggio di programmazione Rust
+---
+
+# Il codice di comportamento di Rust
+
+## Comportamento
+
+**Contatto**: [rust-mods@rust-lang.org](mailto:rust-mods@rust-lang.org)
+
+* Noi ci impegniamo a fornire un ambiente amichevole, sicuro e accomodante per tutti, a prescindere dal livello di esperienza, sesso, identitá ed espressione sessuale, orientamento sessuale, disabilitá, aspetto estetico, dimensione corporea, razza, etnia, etá, religione, nazionalitá o altre caratteristiche personali.
+* Su IRC, evita di utilizzare pseudonimi troppo sessualizzanti o altri pseudonimi che potrebbero rovinare un ambiente amichevole, sicuro e accomodante per tutti.
+* Sii gentile e servizievole. Non c'é alcun bisogno di essere cattivi o maleducati.
+* Rispetta le persone che non la pensano come te e che ogni scelta di design o implementazione porta molti compromessi e cosi. C'é raramente una vera risposta giusta.
+* Per favore limita al minimo la critica non costruttiva. Se hai delle idee valide con cui vuoi sperimentare, fai un fork del progetto e guarda come funziona.
+* Ti impediremo di interagire se insulti, parodizzi o disturbi qualcuno. Quello non é un comportamento accettato. Con "disturbo" intendiamo la definizione che si puó trovare nel Citizen Code of Conduct; se hai qualche dubbio su cosa potrebbe essere incluso in tale concetto, per favore leggi la loro definizione. In particolare non tolleriamo comportamenti che escludono persone appartenenti a gruppi sociali emarginati.
+* La molestia privata é anch'essa inaccettabile. Non interessa chi sei, se stai o sei stato molestato o reso a disagio da un membro della comunitá, per favore contatta uno dei moderatori o qualcuno dal [Team di moderazione](/team.html#Moderation) immediatamente. Che tu sia un frequentatore abituale o un nuovo arrivato, ci interessa rendere questa comunitá un posto sicuro per te.
+* Ogni attivitá pubblicitaria, molesta, offensiva, volutamente provocatoria o ogni ricerca immotivata di attenzione non é benvenuta.
+
+## Moderazione
+
+Queste sono le politiche per mantenere fede al nostro codice di comportamento. Se pensi che una discussione abbia bisogno di moderazione, per favore contatta il [team di Moderazione](/team.html#Moderation).
+
+1. Frasi che violano gli standard del codice di comportamento di Rust, includendo frasi di odio, offensive, oppressive o emarginanti non sono ammesse. (Sono ammesse le imprecazioni ma non se rivolte a altri utenti o con finalitá di odio.)
+2. Frasi che i moderatori giudicano come inappropriate e inaccettabili, anche se non in esplicita violazione del codice di comportamento.
+3. I moderatori reagiranno alle frasi di cui sopra con un avvertimento iniziale.
+4. Se l'avvertimento viene ignorato, l'utente riceverá un allontanamento temporaneo per calmarsi e riflettere.
+5. Se l'utente ritorna e continua a essere problematico verrá allontanato permanentemente.
+6. I moderatori hanno facoltá a loro discrezione di annullare l'allontanamento qualora l'utente sia alla sua prima violazione e offra una sincera scusa alla parte offesa.
+7. Se un moderatore allontana qualcuno e tu non condividi la sua decisione, per favore parlane direttamente con lui o con un altro moderatoe, **in privato**. Le lamentele sui provvedimenti disciplinari non sono ammesse nei luoghi di discussione pubblica.
+8. I moderatori sono impegnati a dare il buon esempio, qualora creassero una situazione inappropriata saranno soggetti a reazioni piú decise.
+
+Nella comunitá di Rust cerchiamo di andare oltre e di prenderci cura l'uno dell'altro, Non cercare solo di essere tecnicamente inattaccabile, cerca di tirare fuori il meglio che hai in te. In particolare evita di dare corda a discussioni offensive, specialmente se fuori argomento; questo troppo spesso conduce a combattimenti inutili, sentimenti offesi e orgoglio ferito. Inoltre puó condurre alcune persone ad abbandonare la comunitá per sempre.
+
+Se qualcuno si fa un problema per qualcosa che hai detto o fatto, resisti all'impulso di essere difensivo. Smetti di fare ció e scusati. Anche se ti senti incompreso o accusato ingiustamente, c'é una discreta possibilitá che tu non ti sia spiegato correttamente - ricordati che é una tua responsabilitá di far sentire gli altri Rustacchiani a loro agio. Tutti vogliono stare insieme e siamo qui in primo luogo perché vogliamo parlare di alta tecnologia. Troverai persone pronte a perdonarti e prenderti in buona fede se otterrai la loro fiducia.
+
+Le politiche di cui sopra si applicano a tutti i luoghi ufficiali di Rust; includendo i canali IRC ufficiali(#rust, #rust-internals, #rust-tools, #rust-libs, #rustc, #rust-beginners, #rust-docs, #rust-community, #rust-lang, and #cargo); i repositories GitHub sotto rust-lang, rust-lang-nursery e rust-lang-deprecated; tutti i forum di rust-lang.org(sers.rust-lang.org, internals.rust-lang.org). Qualora un altro progetto volesse adottare il codice di comportamento di Rust, per favore contatti uno sviluppatore di questi progetti per assistenza. Se volessi usare questo codice di comportamento per il tuo progetto personale ti suggeriamo di menzionare esplicitamente la tua politica di moderazione o di fare una copia includendo la tua politica di moderazione per evitare confusione.
+
+*Adattato e tradotto dall'inglese dalla [politica di Node.js sul trolling](http://blog.izs.me/post/30036893703/policy-on-trolling) e da [Contributor Covenant v1.3.0](http://contributor-covenant.org/version/1/3/0/).*
\ No newline at end of file
diff --git a/it-IT/contribute-bugs.md b/it-IT/contribute-bugs.md
new file mode 100644
index 000000000..a7af376a1
--- /dev/null
+++ b/it-IT/contribute-bugs.md
@@ -0,0 +1,72 @@
+---
+layout: it-IT/default
+title: Contribuire a Rust — trovare, analizzare e risolvere problemi · Linguaggio di programmazione Rust
+---
+
+# Contribuire a Rust — trovare, analizzare e risolvere problemi
+
+La manutenzione giorno per giorno del progetto ruota attorno al
+[controllo bug][issue tracker] e alle [richieste di unione][PR],
+una mano in piú é sempre richiesta.
+Il modo piú semplice per iniziare a contribuire a Rust é guardare
+i bug caratterizzati dalle etichette [E-easy] o [E-mentor].
+Questi bug sono stati raccolti con la finalitá di essere accessibili
+anche per i programmatori di Rust alla loro prima contribuzione.
+
+Nelle problematiche identificate da `E-mentor` uno sviluppatore di Rust
+esperto si offre volontario di aiutarti nella risoluzione del problema e
+a [spedire le tue modifiche con una richiesta di unione su GitHub][pull].
+Potrai contattarlo per discutere del problema direttamente dalla pagina
+di controllo bug [@menzionando][@mentioning] il suo nome in un commento,
+su IRC o tramite email. Nota che ricevendo molte notifiche gli sviluppatori
+Rust potrebbero non vedere il tuo messaggio; non esitare quindi a cercarli
+di contattarli a tutti i costi!
+
+Molti altri progetti in Rust mantengono una lista simile di problematiche
+facili, includendo il browser web [Servo], la libreria [hyper], il suggeritore
+di sintassi [rustfmt], la libreria di supporto a Unix[nix] e la collezione
+di aiuti automatici alla programmazione [clippy].
+
+Anche se Rust possiede una [comprensiva suite di prova][test] c'é
+sempre di piú da controllare.
+I problemi classificati come [E-needstest] indicano le problematiche
+che si pensano risolte ma non possiedono ancora delle verifiche automatiche.
+Scrivere queste verifiche é un ottimo modo per comprendere un nuovo progetto
+e per iniziare a contribuire ad esso.
+
+Rust é continuamente alla ricerca di persone che [analizzino][triage] problemi:
+riprodurli, ridurre la suite di prove automatiche, applicare etichette, chiudere
+i problemi risolti.
+Nota che per applicare etichette é richiesta un'autorizzazione elevata su GitHub
+facilmente ottenibile per coloro che hanno un po' di esperienza con il progetto.
+Chiedi a un [membro del team][team].
+
+Una volta orientato nel progetto e create una serie di richieste di unione
+in una particolare area, considera di iniziare a visionare le richieste altrui:
+la capacitá di saper valutare il codice altrui é un'abilitá rara e sempre
+apprezzata. Non é richiesta alcuna autorizzazione — inizia semplicemente
+a commentare gentilmente e costruttivamente sulle richieste di unione che ti interessano.
+Se vuoi piú informazioni su come fare una buona valutazione del codice altrui
+segui [questa guida][reviews].
+
+
+
+[@mentioning]: https://github.com/blog/821
+[E-easy]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AE-easy
+[E-mentor]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AE-easy+label%3AE-mentor
+[E-needstest]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AE-needstest
+[PR]: https://github.com/rust-lang/rust/pulls
+[Servo]: https://github.com/servo/servo
+[clippy]: https://github.com/Manishearth/rust-clippy
+[hyper]: https://github.com/hyperium/hyper
+[issue tracker]: https://github.com/rust-lang/rust/issues
+[nix]: https://github.com/nix-rust/nix/
+[pull]: https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md#pull-requests
+[reviews]: http://blog.originate.com/blog/2014/09/29/effective-code-reviews/
+[rustfmt]: https://github.com/rust-lang-nursery/rustfmt
+[team]: team.html
+[test]: https://github.com/rust-lang/rust-wiki-backup/blob/master/Note-testsuite.md
+[triage]: https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md#issue-triage
diff --git a/it-IT/contribute-community.md b/it-IT/contribute-community.md
new file mode 100644
index 000000000..2e154b89c
--- /dev/null
+++ b/it-IT/contribute-community.md
@@ -0,0 +1,88 @@
+---
+layout: it-IT/default
+title: Contribuire a Rust — creazione di una comunitá · Linguaggio di programmazione Rust
+---
+
+# Contribuire a Rust — creazione di una comunitá
+
+Aiuta i novizi, spargi la voce, incontra persone interessanti.
+Rendi Rust un esempio brillante di sviluppo open source nel
+modo in cui tutti noi desideriamo che sia.
+
+Controlla il canale [#rust-beginners].
+Qui é dove dirigiamo i nuovi programmatori Rust per chiedere aiuto,
+é quindi vitale che quando succede, venga impartita una risposta
+rapida, accurata e gentile.
+Similarmente su [Stack Overflow], [users.rust-lang.org] e [/r/rust],
+dove i programmatori generalmente richiedono assistenza.
+Se vuoi un aiuto su come rispondere a domande di programmazione
+[consulta questa guida][helpful].
+
+Se sei giá esperto in qualche area del progetto, per favore controlla
+per dei potenziali problemi marcati come [E-easy].
+Quando vedi un problema di cui conosci la soluzione, scrivi una descrizione
+della tua idea e apponi l'etichetta E-easy.
+Nota che quello che potrebbe apparirti come ovvio potrebbe non esserlo
+per nuovo sviluppatore Rust, é quindi importante descrivere chiaramente
+il problema e la soluzione.
+Questo risulta utile anche per analizzare i problemi etichettati come E-easy
+dotati di descrizioni incomplete per migliorarli.
+
+Gli sviluppatori esperti che sono pazienti e riescono a comunicare chiaramente
+dovrebbero considerare [di seguire i nuovi arrivati][mentor].
+Etichetta problemi semplici con [E-mentor] e menziona nei commenti che
+seguirai gli altri, poi attendi di essere contattato dagli utenti
+riguardo al problema e cerca di rispondere prontamente.
+
+Manutenere piccoli impegni non solo fa bene al progetto Rust ma
+anche al suo ecosistema.
+Se un progetto ha un flusso costante di piccoli impegni potresti considerare
+di adottare una soluzione simile anche tu.
+***Questa attivitá di manutenzione é uno dei modi piú efficaci per portare
+nuovi sviluppatori al progetto***. Se hai bisogno di aiuto su come
+assistere i nuovi utenti [leggi questa guida][mentor-guide].
+
+Parla di ció a cui stai lavorando nella rubrica settimanale
+"what's everyone working on this week" su [/r/rust] e [users.rust-lang.org] e
+indica di cosa hai bisogno.
+Questi sono degli ottimi punti di partenza per collaborare.
+
+Diffondi Rust nella tua comunitá locale. I [gruppi utenti][user groups] Rust e
+gli [eventi][events] sono una componente unica ed eccitante dell'esperienza Rust:
+sono tantissimi e sono ovunque!
+Se non ci sei ancora stato, vai e goditi delle nuove esperienze.
+Se non c'é niente riguardante Rust attorno a te, puoi anche considerare di
+organizzare qualcosa. Puoi verificare l'interesse e annunciare gli eventi
+su [/r/rust] o [users.rust-lang.org]. Contatta il [team della comunitá][community team]
+per inserire il tuo evento nel calendario che verrá annunciato anche su
+[Questa Settimana In Rust][This Week in Rust].
+
+Ricordati mentre pubblicizzi Rust di tenere in conto le idee altrui —
+non tutti saranno colpiti da Rust e va bene cosí.
+
+Incontra alti creatori di comunitá Rust su [#rust-community].
+
+
+
+[#rust-beginners]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-beginners
+[#rust-community]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-community
+[/r/rust]: https://reddit.com/r/rust
+[E-easy]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AE-easy
+[E-mentor]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AE-easy+label%3AE-mentor
+[Stack Overflow]: https://stackoverflow.com/questions/tagged/rust
+[This Week in Rust]: https://this-week-in-rust.org
+[community team]: it-IT/team.html#Community
+[events]: https://www.google.com/calendar/embed?src=apd9vmbc22egenmtu5l6c5jbfc@group.calendar.google.com
+[helpful]: https://codeblog.jonskeet.uk/2009/02/17/answering-technical-questions-helpfully/
+[mentor]: https://users.rust-lang.org/t/mentoring-newcomers-to-the-rust-ecosystem/3088
+[mentor-guide]: https://manishearth.github.io/blog/2016/01/03/making-your-open-source-project-newcomer-friendly/
+[user groups]: user-groups.html
+[users.rust-lang.org]: https://users.rust-lang.org
diff --git a/it-IT/contribute-compiler.md b/it-IT/contribute-compiler.md
new file mode 100644
index 000000000..8f4d06558
--- /dev/null
+++ b/it-IT/contribute-compiler.md
@@ -0,0 +1,112 @@
+---
+layout: it-IT/default
+title: Contribuire a Rust — linguaggio, compilatore e la libreria standard · Linguaggio di programmazione Rust
+---
+
+# Contribuire a Rust — linguaggio, compilatore e la libreria standard
+
+Il sorgente della libreria standard e del compilatore sono nel repository principale
+ed essendo la loro manutenzione uno degli obiettivi primari di quel repository
+la maggior parte dei problemi riportati nel tracciatore delle problematiche li riguardano.
+Alcune tra le etichette interessanti includono [A-codegen] per la traduzione di Rust in
+rappresentazione intermedia LLVM; [A-debuginfo], la generazione di metadati utilizzata
+per la risoluzione dei problemi; [A-diagnostics] per gli errori mostrati dal compilatore;
+[A-libs] per i problemi con la libreria standard; [A-macros] e [A-syntaxext], entrambi
+dedicati all'espansione della sintassi e [A-typesystem] per parlare dei tipi.
+
+Non esiste alcuna guida ben mantenuta all'architettura del compilatore
+ma ne [esiste una piccola carrellata nel repository principale][rustc-guide].
+La [documentazione delle API che compongono il compilatore][internals-docs]
+possono aiutarti a navigare il codice, come puó farlo anche il navigatore di codice
+[Rust DXR]. La [guida per Rust e la sua piattaforma di controllo][testsuite]
+ti insegnerá come utilizzare al meglio il sistema di compilazione di Rust,
+come farebbe anche il comando [`make tips`][tips] da riga di comando.
+
+Per il futuro prossimo, una delle maggiori spinte per il compilatore Rust
+é convertire le sue componenti interne per lavorare direttamente dall'Albero
+di Sintassi Astratto, per elaborare su una [rappresentazione intermedia chiamata MIR][mir].
+Questo lavoro si preannuncia come l'inizio di molte nuove possibilitá
+per semplificare il compilatore ed é richiesto dell'aiuto per esempio
+creare una fase di traduzione basata su MIR, ottimizzare la MIR e implementare
+la compilazione incrementale.
+Non esiste una fonte unica per informazioni sul lavoro richiesto ma chiedi
+su [internals.rust-lang.org] o su
+[#rust-internals] per ulteriori informazioni.
+
+[É imbarazzante se il nostro compilatore si blocca][ice] — il
+nefasto 'errore interno di compilazione' ('internal compiler error' ICE).
+L'etichetta [I-ICE] tiene traccia di questi problemi e spesso sono molti.
+Questi sono usualmente degli ottimi problemi per iniziare a contribuire
+perché é facile comprendere quando vengono riparati e sono relativamente
+isolati dal resto del codice.
+
+Le prestazioni di Rust é uno dei suoi piú grossi vantaggi; e quella
+del suo compilatore é uno dei suoi piú grossi problemi.
+Ogni miglioramento della prestazione degli eseguibili or — specialmente —
+delle prestazioni del compilatore sono largamente celebrati.
+Le etichette [I-slow] e [A-optimization] si occupano delle prestazioni
+degli eseguibili e [I-compiletime] di quella del compilatore. Abbiamo un
+[sito che tiene traccia delle prestazioni del compilatore][rustc-perf]
+durante alcuni carichi di lavoro.
+L'opzione da riga di comando `-Z time-passes` puó aiutare a ispezionare
+le prestazioni del compilatore e il codice di Rust puó essere profilato
+da tutti i profilatori standard come `perf` su Linux.
+
+Funzionalitá importanti passano attraverso il processo di [Request for Comments (RFC)][rfc]
+dal quale ci si accorda sul design. Anche se aperto a tutti é un'interazione tra
+sviluppatori che giá hanno un discreto quantitivo di esperienza in comune ed é
+consigliato prendere parte al processo lentamente —
+inviare una RFC ostica senza comprendere il contesto storico, tecnico o sociale
+é un modo facile per dare una cattiva impressione e andarsene delusi.
+Leggi il collegamento sopra per comprendere al meglio come tutto il sistema funziona.
+Molte idee sono giá state discusse durante il passato di Rust, alcune sono state
+rifiutate, altre rimandate al futuro e la [portale delle RFC][rfc-issues]
+elenca alcune idee desiderate che non sono ancora riuscite a entrare
+nel linguaggio.
+Poco prima che una RFC venga accettata per l'implementazione, entra in
+una 'fase finale di commento' indicata dall'etichetta
+[final-comment-period sul repository rust-lang/rfcs][rfc-fcp].
+Similarmente, prima che una funzionalitá venga abilitata nel compilatore
+stabile (procedura definita 'ungating') essa entra nella [final-comment-period sul repository rust-lang/rust][issue-fcp].
+Entrambe le fasi di commento finale sono momenti critici per essere coinvolti
+ed esprimere opinioni sulla direzione del linguaggio e sono indicate
+nei report settimanali dei vari gruppi di lavoro su [internals.rust-lang.org].
+
+Incontra altri progettisti di compilatori su [#rustc], progettisti del linguaggio
+su [#rust-lang] e progettisti di librerie su [#rust-libs].
+
+
+
+
+[#rust-internals]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-internals
+[#rust-lang]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-lang
+[#rust-libs]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-libs
+[#rustc]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rustc
+[A-codegen]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-codegen
+[A-debuginfo]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-debuginfo
+[A-diagnostics]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-diagnostics
+[A-libs]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-libs
+[A-macros]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-macros
+[A-optimization]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-optimization
+[A-syntaxext]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-syntaxext
+[A-typesystem]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-typesystem
+[I-ICE]: https://github.com/rust-lang/rust/labels/I-ICE
+[I-compiletime]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AI-compiletime
+[I-slow]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AI-slow
+[Rust DXR]: https://dxr.mozilla.org/rust/source/src
+[ice]: https://users.rust-lang.org/t/glacier-a-big-ol-pile-of-ice/3380
+[internals-docs]: https://manishearth.github.io/rust-internals-docs
+[internals.rust-lang.org]: https://internals.rust-lang.org/
+[issue-fcp]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AB-unstable+label%3Afinal-comment-period
+[mir]: https://github.com/rust-lang/rust/issues/27840
+[rfc-fcp]: https://github.com/rust-lang/rfcs/pulls?q=is%3Aopen+is%3Apr+label%3Afinal-comment-period
+[rfc-issues]: https://github.com/rust-lang/rfcs/issues
+[rfc]: https://github.com/rust-lang/rfcs#table-of-contents
+[rustc-guide]: https://github.com/rust-lang/rust/blob/master/src/librustc/README.md
+[rustc-perf]: http://ncameron.org/perf-rustc/
+[testsuite]: https://github.com/rust-lang/rust-wiki-backup/blob/master/Note-testsuite.md
+[tips]: https://github.com/rust-lang/rust/blob/3d1f3c9d389d46607ae28c51cc94c1f43d65f3f9/Makefile.in#L48
diff --git a/it-IT/contribute-docs.md b/it-IT/contribute-docs.md
new file mode 100644
index 000000000..df086cd62
--- /dev/null
+++ b/it-IT/contribute-docs.md
@@ -0,0 +1,70 @@
+---
+layout: it-IT/default
+title: Contribuire a Rust — documentazione · Linguaggio di programmazione Rust
+---
+
+# Contribuire a Rust — documentazione
+
+La documentazione non é mai abbastanza buona e non ce n'é mai troppa.
+Molti aspetti della documentazione di Rust non richiedono una profonda conoscenza
+per essere migliorati, scritti, corretti o modificati, inoltre modificare la documentazione
+é un ottimo modo per imparare Rust.
+Ulteriormente i miglioramenti sono semplici da identificare e potenzialmente infiniti:
+non ti piace come suona una frase? Hai scoperto qualcosa che nella documentazione non é presente?
+La tua richiesta di modifica verrá calorosamente accolta.
+
+***La documentazione piú importante che tu possa scrivere é per [i pacchetti
+che fanno parte dell'ecosistema di Rust][crate_docs]***.
+Mentre la documentazione principale é relativamente esaustiva, ció non é vero
+per [molti pacchetti e strumenti popolari][awesome-rust] con cui gli sviluppatori
+Rust interagiscono ogni giorno.
+Contribuire alla documentazione delle API per un progetto popolare ti garantirá
+l'amore da parte dello sviluppatore del progetto.
+
+[Il libro][The Book] é la documentazione base per Rust,
+scritto nel repository principale.
+Possiede anche la sua etichetta per le problematiche, [A-book] ed
+é continuamente in miglioramento.
+Ulteriore documentazione nel repository principale include [il riferimento di Rust][The Rust Reference],
+la [documentazione della libreria standard][std], [Il Rustonomico][The Rustonomicon] (un guida su come usare `unsafe`
+correttamente). Le [guide di stile di Rust][Rust Style Guidelines] sono cosí incomplete che non vengono elencate spesso;
+uno sviluppatore ambizioso puó sicuramente fare molta strada contribuendo lí.
+L'[indice degli errori][err] fornisce spiegazioni dettagliate agli errori del compilatore.
+Quando vengono aggiunti nuovi errori, essi devono essere [inclusi nella documentazione][err-issue], quindi ci sono
+sempre errori non presenti ancora ma con la necessitá di essere aggiunti.
+La maggior parte della documentazione nel repository principale risiede nella cartella [src/doc].
+Tutti i problemi di documentazione sono sotto all'etichetta [A-docs] sul portale delle problematiche.
+Finalmente questo documento e altri correlati con il sito web sono mantenuti nel [repository Git del sito][Rust website Git repository].
+Per contribuire modificalo e manda una pull request.
+
+Una buona quantitá di documentazione importante per Rust non si trova
+nel repository principale o non é mantenuta dal progetto Rust ma é
+comunque importantissima per il successo di Rust.
+Esempi di documentazione eccellente sotto attivo sviluppo con domanda
+per altri sviluppatori includono [Rust By Example], [Rust Design Patterns] e [rust-rosetta].
+Per altri progetti di documentazione esistenti a cui contribuire vedi [rust-learning].
+
+Incontra altri documentatori su [#rust-docs].
+
+
+
+[#rust-docs]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-docs
+[A-book]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-book
+[A-docs]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-docs
+[Rust By Example]: https://github.com/rust-lang/rust-by-example
+[Rust Design Patterns]: https://github.com/nrc/patterns
+[Rust Style Guidelines]: https://doc.rust-lang.org/style/index.html
+[The Book]: https://doc.rust-lang.org/book/index.html
+[The Rust Reference]: https://doc.rust-lang.org/reference.html
+[The Rustonomicon]: https://doc.rust-lang.org/nomicon/index.html
+[awesome-rust]: https://github.com/kud1ing/awesome-rust
+[crate_docs]: https://users.rust-lang.org/t/lets-talk-about-ecosystem-documentation/2791
+[err-issue]: https://github.com/rust-lang/rust/issues/24407
+[err]: https://doc.rust-lang.org/error-index.html
+[rust-learning]: https://github.com/ctjhoa/rust-learning
+[rust-rosetta]: https://github.com/Hoverbear/rust-rosetta
+[src/doc]: https://github.com/rust-lang/rust/tree/master/src/doc
+[std]: https://doc.rust-lang.org/std/index.html
+[Rust website Git repository]: https://github.com/rust-lang/rust-www
diff --git a/it-IT/contribute-libs.md b/it-IT/contribute-libs.md
new file mode 100644
index 000000000..ad698019b
--- /dev/null
+++ b/it-IT/contribute-libs.md
@@ -0,0 +1,63 @@
+---
+layout: it-IT/default
+title: Contribuire a Rust — librerie · Linguaggio di programmazione Rust
+---
+
+# Contribuire a Rust — librerie
+
+Se vuoi contribuire a Rust scrivendo molto codice,
+le librerie sono il modo per farlo: visto che Rust é ancora
+un linguaggio giovane, ci sono ancora molti tipi di librerie che
+o non esistono ancora o sono incompleti e necessitano di miglioramenti o competizione.
+
+Decidere cosa scrivere per avere un impatto ed essere divertenti sono due difficoltá comuni.
+Ecco alcune idee:
+* Leggi e partecipa ai "what's everyone working on this week" su [/r/rust]
+ e [users.rust-lang.org]. Questi forum sono pieni di annunci emozionanti
+ da parte di altri sviluppatori in cerca di aiuto.
+* Familiarizza con le migliori librerie Rust con
+ [awesome-rust] e [libs.rs].
+* Alcuni progetti grandi, incluso il browser web [Servo], la libreria HTTP [hyper],
+ il suggeritore di sintassi [rustfmt], la libreria di integrazione con Unix[nix] e
+ il suggeritore automatico [clippy], includono delle problematiche identificate
+ come 'easy' specifiche per i nuovi sviluppatori.
+* Fatti coinvolgere in una delle organizzazioni Rust-centriche su GitHub
+ tipo [PistonDevelopers], [servo], [redox-os],
+ [iron], [contain-rs], [hyperium]. Spesso é piú facile ricavarsi un posto
+ in queste comunitá, che hanno ancora piú bisogno di rust-lang stesso.
+ Sono anche piene di sviluppatori Rust esperti che possono aiutarti.
+* Aiuta il passaggio delle librerie da [rust-lang-nursery] a rust-lang.
+ Sfortunatamente non vi é ancora molta documentazione su cosa sia necessario fare.
+ Puoi comunque chiedere su [#rust-libs].
+* Ispeziona le RFC di una [libreria richiesta dalla community][requested] e creala.
+* Guarda [ció che é in voga su Github][trending] per vedere altri progetti Rust attivi.
+
+Come autore di librerie potresti desiderare di essere a conoscenza dei
+[migliori consigli su come implementare una libreria Rust][lib-prac].
+
+Incontrati con gli altri progettisti di librerie su [#rust-libs].
+
+
+
+[#rust-libs]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-libs
+[/r/rust]: https://reddit.com/r/rust
+[PistonDevelopers]: https://github.com/PistonDevelopers
+[Servo]: https://github.com/servo/servo
+[Servo]: https://github.com/servo/servo
+[awesome-rust]: https://github.com/kud1ing/awesome-rust
+[clippy]: https://github.com/Manishearth/rust-clippy
+[contain-rs]: https://github.com/contain-rs
+[hyper]: https://github.com/hyperium/hyper
+[hyperium]: https://github.com/hyperium
+[iron]: https://github.com/iron
+[lib-prac]: https://pascalhertleif.de/artikel/good-practices-for-writing-rust-libraries/
+[libs.rs]: http://libs.rs
+[nix]: https://github.com/nix-rust/nix/
+[redox-os]: https://github.com/redox-os
+[requested]: https://github.com/rust-lang/rfcs/labels/A-community-library
+[rust-lang-nursery]: https://github.com/rust-lang-nursery
+[rustfmt]: https://github.com/rust-lang-nursery/rustfmt
+[trending]: https://github.com/trending?l=rust
+[users.rust-lang.org]: https://users.rust-lang.org
diff --git a/it-IT/contribute-tools.md b/it-IT/contribute-tools.md
new file mode 100644
index 000000000..d98eef8a3
--- /dev/null
+++ b/it-IT/contribute-tools.md
@@ -0,0 +1,48 @@
+---
+layout: it-IT/default
+title: Contribuire a Rust — strumenti, ambienti di sviluppo e infrastrutture · Linguaggio di programmazione Rust
+---
+
+# Contribuire a Rust — strumenti, ambienti di sviluppo e infrastrutture
+
+Gli strumenti giocano una parte fondamentale nel successo di un linguaggio
+e rimangono ancora molte cose da implementare.
+***Al momento buona parte dello sviluppo in questa area di Rust si concentra
+sul [migliorare l'esperienza con gli ambienti di sviluppo][ides]***.
+Questo richiede impegno da parte di tutto l'ecosistema Rust, dal compilatore
+stesso fino al tuo ambiente di sviluppo preferito.
+Segui il link per saperne di piú.
+
+Sia Cargo, il gestore di pacchetti di Rust e rustdoc
+il generatore di documentazione per Rust, sebbene
+siano in possesso di tutte le funzioni richieste e
+validamente funzionanti, soffrono di una carenza di sviluppatori.
+Rustdoc ha molte problematiche aperte sotto l'etichetta
+[A-rustdoc] del repository principale.
+Queste problematiche sono principalmente composte da
+errori e contribuire é semplicmente una questione di
+risolverli e inviare una richiesta di unione.
+Cargo, possiede [il suo personale repository con relativi problemi][Cargo],
+coloro fossero interessati a contribuire possono anche presentarsi
+nel canale IRC [#cargo].
+
+Anche se Rust funziona sia con il debugger gdb che in lldb con discreti
+risultati, ci sono ancora molti casi in cui la risoluzione di problemi
+non funziona come previsto. L'etichetta [A-debuginfo] segue proprio
+questi problemi.
+
+Per idee su altri strumenti a cui contribuire vedi
+[awesome-rust].
+
+Ci sono spesso altri progetti interessanti di strumenti in attesa
+giusto di persone che possano venire ad implementarli.
+Vieni a discuterne con gli altri appassionati di questo aspetto di
+Rust su [#rust-tools].
+
+[#cargo]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rustc
+[#rust-tools]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-tools
+[A-debuginfo]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-debuginfo
+[A-rustdoc]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-rustdoc
+[Cargo]: https://github.com/rust-lang/cargo/issues
+[awesome-rust]: https://github.com/kud1ing/awesome-rust
+[ides]: https://forge.rust-lang.org/ides.html
diff --git a/it-IT/contribute-translations.md b/it-IT/contribute-translations.md
new file mode 100644
index 000000000..878a863ef
--- /dev/null
+++ b/it-IT/contribute-translations.md
@@ -0,0 +1,8 @@
+---
+layout: it-IT/default
+title: Tradurre rust-lang.org in altri linguaggi per adottare l'internazionalizzazione
+---
+
+# Rust é universale
+
+Manca la documentazione su come contribuire a tradurre!
diff --git a/it-IT/contribute.md b/it-IT/contribute.md
new file mode 100644
index 000000000..3e06c74a3
--- /dev/null
+++ b/it-IT/contribute.md
@@ -0,0 +1,62 @@
+---
+layout: it-IT/default
+title: Contribuire a Rust · Linguaggio di programmazione Rust
+---
+
+# Contribuire a Rust
+
+Una volta iniziato a imparare Rust. Lo amerai e vorrai divenire parte di esso.
+Se non sei sicuro su come essere coinvolto, questa pagina ti aiuterá.
+
+**Trovato un problema e vuoi notificarlo?** [segui la guida su come riportare i problemi][bugs]. Grazie in anticipo!
+
+Rust é un espanso sistema di progetti, in cui i piú prominenti di questions
+sono mantenuti dagli [sviluppatori del progetto Rust][devs] nella [organizzazione
+rust-lang su GitHub][rust-lang].
+I nuovi arrivati potrebbero essere interessati al file [CONTRIBUTING.md]
+che illustra le meccaniche con cui contribuire a [rust-lang/rust].
+
+Ci sono molti modi per contribuire al successo di Rust.
+Questa guida indica alcune strade per i nuovi arrivati:
+
+* [Trovare, gestire e risolvere problematiche](contribute-bugs.html). Il
+ lavoro base per mantenere un progetto grande e attivo come Rust
+* [Documentazione](contribute-docs.html). Non solo
+ documentazione ufficiale ma anche per pacchetti, post sul blog
+ e altre fonti non ufficiali.
+* [Creazione di comunitá](contribute-community.html). Aiutare gli altri
+ Rustacchiani e espandendo le frontiere di Rust.
+* [Strumenti, ambienti di sviluppo e infrastrutture](contribute-tools.html). Gli
+ importanti pezzi che rendono un linguaggio pratico e piacevole.
+* [Librerie](contribute-libs.html). L'idoneitá di Rust a un compito
+ é subordinata alla presenza di librerie di alta qualitá.
+* [Liguaggio, compilatore e la libreria
+ standard](contribute-compiler.html). Design del linguaggio, implementazione
+ funzionalitá, ottimizzazioni.
+* [Internazionalizzazione](contribute-translations.html). Aiuta a spargere
+ l'amore per Rust traducendo il nostro sito in altre lingue.
+
+Se hai bisogno di ulteriore aiuto chiedi su [#rust-internals] o su
+[internals.rust-lang.org].
+
+Siamo orgogliosi di mantenere discussioni civili e con questo scopo
+i nostri sviluppatori sono tenuti a seguire il [codice di comportamento][coc].
+If hai delle domande a questo proposito per favore parlane con il [Team comunitá][community team].
+
+
+
+[#rust-internals]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-internals
+[CONTRIBUTING.md]: https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md
+[bugs]: https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md#bug-reports
+[coc]: https://www.rust-lang.org/it-IT/conduct.html
+[community team]: https://www.rust-lang.org/team.html#Community
+[dev_proc]: community.html#rust-development
+[devs]: https://github.com/rust-lang/rust/graphs/contributors
+[internals.rust-lang.org]: https://internals.rust-lang.org/
+[rust-lang/rust]: https://github.com/rust-lang/rust
+[rust-lang]: https://github.com/rust-lang
diff --git a/it-IT/documentation.md b/it-IT/documentation.md
new file mode 100644
index 000000000..f1faa8fe2
--- /dev/null
+++ b/it-IT/documentation.md
@@ -0,0 +1,101 @@
+---
+layout: it-IT/default
+title: Documentazione di Rust · Linguaggio di programmazione Rust
+---
+
+# Documentazione di Rust
+
+Se non hai proprio mai visto Rust, la prima cosa che dovresti leggere
+é l'introduzione del [Libro di Rust][book].
+Ti dará una buona idea di com'é Rust, ti mostrerá come installarlo,
+illustrando anche la sua sintassi e i suoi concetti.
+Una volta letto sarai uno sviluppatore Rust discreto e avrai una
+buona idea dei concetti fondamentali di Rust.
+
+## Imparare Rust
+
+[Il Libro di Rust][book]. Conosciuto anche come "Il libro",
+é la risorsa piú completa per tutti gli argomenti correlati a Rust e
+rappresenta il documento primario ufficiale del linguaggio.
+
+[Rust per Esempi][rbe]. Una collezione di diversi problemi indipendenti
+commentati e eseguibili dal browser.
+
+[Domande Frequenti][faq].
+
+[Il Rustonomicon][nomicon].
+Un intero libro dedicato a scrivere codice Rust insicuro.
+Dedicato ai programmatori Rust esperti.
+
+[rust-learning]. Una risorsa fornita dalla comunitá di fonti dove imparare Rust.
+
+[book]: https://doc.rust-lang.org/book/
+[rbe]: http://rustbyexample.com
+[faq]: faq.html
+[nomicon]: https://doc.rust-lang.org/nomicon/
+[rust-learning]: https://github.com/ctjhoa/rust-learning
+
+## Riferimenti
+
+[Riferimento della libreria standard][api]. Documentazione sull'utilizzo della libreria standard.
+
+[docs.rs]. Documentazione per i pacchetti rilasciati su [crates.io].
+
+[Riferimento del linguaggio Rust][ref].
+Anche se Rust non ha una specifica, il riferimento
+prova a spiegare il suo funzionamento nel dettaglio.
+Spesso non é aggiornato.
+
+[Indice sintassi][syn].
+Questa appendice del Libro di Rust contiene esempi di tutte
+le sintassi menzionate nel libro, descrivendole.
+
+[La guida di Cargo][cargo]. La documentazione di Cargo,
+il gestore di pacchetti di Rust.
+
+[Indice errori compilatore][err]. Spiegazioni dettagliate agli
+errori emessi dal compilatore Rust.
+
+[Note di rilascio][release_notes]. Un archivio delle modifiche apportate in ciascuna versione.
+
+[api]: https://doc.rust-lang.org/std/
+[syn]: https://doc.rust-lang.org/book/syntax-index.html
+[ref]: https://doc.rust-lang.org/reference.html
+[cargo]: http://doc.crates.io/guide.html
+[err]: https://doc.rust-lang.org/error-index.html
+[release_notes]: https://github.com/rust-lang/rust/blob/stable/RELEASES.md
+[docs.rs]: https://docs.rs
+[crates.io]: https://crates.io
+
+## Politiche del progetto
+
+[Politica rilascio vulnerabilitá][security]. Le politiche del progetto
+per notificare, risolvere e rivelare problematiche di sicurezza.
+
+[Diritti sul nome e marchio di Rust][legal]. I diritti di Rust
+appartengono agli sviluppatori del Progetto Rust, i suoi marchi
+sono proprietá di Mozilla. Nel collegamento si possono trovare le
+norme di utilizzo.
+
+[Codice di comportamento][coc]. Si applica all' organizzazione rust-lang
+su GitHub, i forum ufficiali, i canali IRC e in diversi angoli del mondo di Rust.
+
+[security]: security.html
+[legal]: legal.html
+[coc]: https://www.rust-lang.org/it-IT/conduct.html
+
+## Documentazione versioni nightly e beta
+
+La maggior parte della documentazione ufficiale di Rust é disponibile
+anche per le versioni [nightly] e [beta], in aggiunta alla documentazione
+menzionata sopra.
+
+[nightly]: https://doc.rust-lang.org/nightly/
+[beta]: https://doc.rust-lang.org/beta/
+
+## Risorse non inglesi
+
+Per risorse non in lingua inglese
+[risorse in lingua su rust-learning][locale].
+
+[locale]: https://github.com/ctjhoa/rust-learning#locale-links
diff --git a/it-IT/downloads.html b/it-IT/downloads.html
new file mode 100644
index 000000000..0f3bde88d
--- /dev/null
+++ b/it-IT/downloads.html
@@ -0,0 +1,5 @@
+
+
+
+
+
diff --git a/it-IT/faq.md b/it-IT/faq.md
new file mode 100644
index 000000000..916232229
--- /dev/null
+++ b/it-IT/faq.md
@@ -0,0 +1,1891 @@
+---
+layout: it-IT/basic
+title: Domande Frequenti · Linguaggio di programmazione Rust
+---
+
+# Domande Frequenti
+
+
+Questa pagina esiste per rispondere a domande comuni inerenti il linguaggio di programmazione Rust.
+Non rappresenta una guida completa al linguaggio e nemmeno uno strumento per insegnarlo.
+Costituisce invece un riferimento per rispondere alle domande piú frequenti concernenti le scelte di progettazione dietro a Rust.
+
+
+
+Se c'é una domanda comune o importante che pensi sia ingiustamente non inclusa qui, sentiti libero di aiutarci ad aggiungerla.
+
+
+Progettare e implementare un linguaggio sicuro, concorrente e pratico per la programmazione di sistemi.
+
+Rust nasce perché altri linguaggi a questo livello di astrazione e efficienza non sono soddisfacenti. In particolare:
+
+1. Non viene posta la dovuta attenzione alla sicurezza.
+2. Supportano malamente la concorrenza.
+3. Vi é una carenza di ergonomia.
+4. Offrono un controllo limitato delle risorse.
+
+Rust esiste come un'alternativa che fornisce sia codice efficiente che un livello confortevole di astrazione, contemporaneamente migliorando tutti questi quattro punti.
+
+No. Rust é iniziato come un progetto hobbystico da parte di Graydon Hoare nel 2006 ed é rimasto cosí per oltre 3 anni. La Mozilla é entrata nel 2009, dopo che il linguaggio si é dimostrato abbastanza maturo per eseguire una serie di basici test automatizzati e dimostrare la valenza dei suoi principi base. Anche se sponsorizzato da Mozilla, Rust é un progetto sviluppato da
+una variegata comunitá di appassionati da molti paesi del mondo. Il [Team di Rust](team.html) é composto sia da membri Mozilla che da esterni e `rust` su GitHub ha avuto oltre [1,500 sviluppatori diversi](https://github.com/rust-lang/rust/) fino ad oggi.
+
+Finché concesso [dalla politica di gestione del progetto](https://github.com/rust-lang/rfcs/blob/master/text/1068-rust-governance.md), Rust é amministrato da un team base che imposta
+la visione e le prioritá del progetto, guidandolo globalmente.
+Esistono anche dei sottogruppi per guidare e incoraggiare lo sviluppo in alcune aree di interesse, inclusi il linguaggio, il compilatore, le librerie, gli strumenti, la moderazione delle comunitá ufficiali.
+La progettazione é guidata da un processo [RFC](https://github.com/rust-lang/rfcs).
+Per cambiamenti che non richiedono una RFC, le decisioni sono fatte attraverso richieste di unione sul [repository `rustc`](https://github.com/rust-lang/rust).
+
+
+
+1. Non impieghiamo nessuna tecnologia particolarmente nuova. Le vecchie tecniche ben consolidate sono meglio.
+2. Non ci preme incentivare l'espressivitá, il minimalismo o l'eleganza sopra ogni altra cosa. Sono obiettivi desiderati ma non fondamentali.
+3. Non ci interessa coprire tutte le funzionalitá del C++ o di qualsiasi altro linguaggio. Rust dovrebbe fornire le funzionalitá piú richieste.
+4. Non vogliamo essere immobili al 100%, sicuri al 100%, riflessivi al 100% o troppo dogmatici in qualche modo. Esistono dei compromessi.
+5. Non domandiamo che Rust funzioni "su ogni piattaforma possibile". Dovrá eventualmente funzionare senza inutili compromessi sulle piattaforme hardware e software piú diffuse.
+
+
+
+Principalmente in [Servo](https://github.com/servo/servo), un motore di navigazione sperimentale a cui Mozilla sta lavorando. Stanno anche lavorando per [integrare componenti Rust](https://bugzilla.mozilla.org/show_bug.cgi?id=1135640) in Firefox.
+
+
+
+I due piú grandi progetti open source sono al momento [Servo](https://github.com/servo/servo) e il [compilatore Rust](https://github.com/rust-lang/rust) stesso.
+
+
+
+Il modo piú facile per provare Rust é sulla [playpen](https://play.rust-lang.org/), un'applicazione online per scrivere e provare codice Rust. Se invece desideri provare Rust sul tuo computer, [installalo](https://www.rust-lang.org/install.html) e prova a seguire la guida al [gioco dell'indovino](https://doc.rust-lang.org/stable/book/guessing-game.html) dal libro.
+
+
+
+Ci sono diversi modi. Puoi:
+
+- Scrivere su [users.rust-lang.org](https://users.rust-lang.org/), il forum ufficiale di Rust
+- Chiedere sul [canale IRC ufficiale di Rust](https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust) (#rust on irc.mozilla.org)
+- Chiedere su [Stack Overflow](https://stackoverflow.com/questions/tagged/rust) with the "rust" tag
+- Scrivere su [/r/rust](https://www.reddit.com/r/rust), il subreddit non ufficiale di Rust
+
+
+
+Rust é iniziato con l'obiettivo di creare un linguaggio di programmazione per sistemi stabile e utilizzabile. Per perseguire questo scopo ha esplorato molte idee, alcune sono state preservate(campi di esistenza, tratti) mentre altre sono state scartate (il sistema di stati dei tipi, il green threading).
+Inoltre durante la transizione verso la versione 1.0, buona parte della libreria standard é stata riscritta per consentire al codice passato di sfruttare al meglio le funzionalitá di Rust,
+fornendo interfacce di programmazione di qualitá, stabili e multipiattaforma.
+Ora che Rust é alla versione 1.0, il linguaggio é garantito come "stabile"; e mentre potrebbe continuare ad evolversi, il codice funzionante sulla versione attuale dovrebbe continuare a farlo
+anche nelle versioni future.
+
+
+
+Rust segue lo standard [SemVer](http://semver.org/), dove cambiamenti non compatibili con le versioni passate sono ammesse nelle versioni minori se questi cambiamenti
+risolvono errori del compilatore, risolvono problemi di sicurezza o cambiano le regole di dichiarazione o inferenza dei tipi in modo da richiedere ulteriore specifica.
+Linee guida piú dettagliate per cambi di versione minori sono disponibili come RFC approvate sia per il [linguaggio](https://github.com/rust-lang/rfcs/blob/master/text/1122-language-semver.md) che per la [libreria standard](https://github.com/rust-lang/rfcs/blob/master/text/1105-api-evolution.md).
+
+Rust mantiene tre canali di rilascio: stabile, beta e "nightly".
+I canali stabile e beta sono aggiornati ogni sei settimane, con la nightly che diviene la nuova beta e la beta che diviene la nuova stabile.
+Le funzionalitá del linguaggio e della libreria standard indicate come non stabili o nascoste dietro a blocchi di implementazione possono essere utilizzati solo
+nel canale di rilascio "nightly". Le nuove funzionalitá arrivano come instabili ma sono "liberate" una volta approvate dal team di sviluppo e relativi sottogruppi.
+Questo approccio consente di sperimentare e di contemporaneamente fornire una forte garanzia di retrompatibilitá del canale stabile.
+
+Per dettagli ulteriori, leggi il post sul blog di Rust ["Stability as a Deliverable."](http://blog.rust-lang.org/2014/10/30/Stability.html)
+
+
+
+No, non puoi. Rust cerca duramente di fornire garanzie sulla stabilitá delle funzioni incluse nei canali beta e stabile.
+Quando qualcosa é non stabile significa che non é possibile ancora garantire il suo utilizzo e quindi non desideriamo che ci
+si basi su queste funzionalitá o che queste non vengano modificate.
+Questo ci permette di provare i cambiamenti nel canale nightly, preservando le promesse di stabilitá.
+
+Molte cose vengono incluse nella stabile e i canali beta e stabile vengono aggiornati ogni sei settimane, con occasionali modifiche dirette anche al canale beta a volte.
+Se stai aspettando la disponbilitá di una funzionalitá e non vuoi usufruire del canale nighly, puoi seguirne lo stato controllando l'etichetta [`B-unstable`](https://github.com/rust-lang/rust/issues?q=is%3Aissue+is%3Aopen+tracking+label%3AB-unstable) sulla bacheca dei problemi.
+
+
+
+I "Feature gates" sono il modo con cui Rust stabilizza funzionalitá del compilatore, del linguaggio e della libreria standard.
+Una funzione protetta é accessibile esclusivamente nel canale di rilascio "nighly" e solo quando abilitata esplicitamente con la direttiva `#[feature]` o con l'argomento a linea di comando `-Z unstable-options`.
+Quando una funzione é stabilizzata diviene disponbile sul canale di rilascio stabile e non é necessario abilitarla esplicitamente.
+A quel punto la funzione é considerata "libera".
+I "Feature gates" consentono agli sviluppatori di provare funzionalitá sperimentali mentre sono in fase di implementazione, prima che giungano nel linguaggio stabile.
+
+
+
+La licenza Apache include importanti protezioni contro le aggressioni legali ma non é compatibile con la GPL versione 2.
+Per evitare problemi nell'utilizzo di Rust e GPL2 é aggiunta la licenza alternativa MIT.
+
+
+
+Questo é parzialmente dovuto alla preferenza dello sviluppatore originario (Graydon) e parzialmente al fatto che i linguaggi tendono ad avere un pubblico piú vasto e una serie piú variegata di implementazioni e utilizzi di altri prodotti come i browser web. Noi vorremmo appellarci al maggior numero possibile di sviluppatori.
+
+
+
+Molto! Rust é giá competitivo con programmi C e C++ ben scritti in una serie di prove (come nel [Benchmarks Game](https://benchmarksgame.alioth.debian.org/u64q/compare.php?lang=rust&lang2=gpp) e [altri](https://github.com/kostya/benchmarks)).
+
+Come il C++, il Rust possiede [astrazioni a costo zero](http://blog.rust-lang.org/2015/05/11/traits.html) come uno dei suoi principi chiave: nessuna delle astrazioni di Rust impone un rallentamento, in qualsiasi caso.
+
+Dato che Rust utilizza LLVM e cerca di assomigliare a Clang dal punto di vista dell'interazione con LLVM, ogni miglioramento di LLVM é condiviso da Rust.
+Nel lungo periodo, la quantitá elevata di informazioni presente nel sistema dei tipi di Rust dovrebbe permettere ottimizzazioni difficili o impossibili da implementare in C/C++.
+
+
+
+No. Una delle innovazioni fondamentali di Rust é il garantire la sicurezza della memoria (nessun errore di segmentazione) *senza* richiedere un garbage collector.
+
+Evitando di utilizzare un GC, Rust offre numerosi vantaggi: liberazione prevedibile delle risorse, gestione della memoria meno onerosa e soprattutto nessun sistema aggiuntivo operante durante l'esecuzione.
+Tutte queste caratteristiche rendono Rust leggero e facile da implementare in contesti arbitrari e rendono piú facile [integrare Rust con i linguaggi in possesso di un GC](http://calculist.org/blog/2015/12/23/neon-node-rust/).
+
+Rust non necessita di un GC grazie al suo sistema di possesso e passaggio ma lo stesso sistema aiuta con una moltitudine di altri problemi, inclusi [la gestione delle risorse in generale](http://blog.skylight.io/rust-means-never-having-to-close-a-socket/)
+e la [concorrenza](http://blog.rust-lang.org/2015/04/10/Fearless-Concurrency.html).
+
+Per quando il possesso di un valore non fosse abbastanza, i programmi Rust fanno riferimento al tipo puntatore intelligente standard a conteggio dei riferimenti [`Rc`](https://doc.rust-lang.org/std/rc/struct.Rc.html) e alla sua versione sicura in contesti paralleli [`Arc`](https://doc.rust-lang.org/std/sync/struct.Arc.html), invece di affidarsi a un GC.
+
+Stiamo comunque investigando una garbage collection *opzionale* come estensione futura.
+L'obiettivo é integrarsi fluidamente con ambienti garbage-collected, come quelli offerti dai
+motori di Javascript [Spidermonkey](https://developer.mozilla.org/en-US/docs/Mozilla/Projects/SpiderMonkey) e [V8](https://developers.google.com/v8/?hl=en).
+Inoltre, qualcuno sta investigando l'implementazione di un garbage collector
+[interamente in Rust](https://manishearth.github.io/blog/2015/09/01/designing-a-gc-in-rust/)
+senza supporto del compilatore.
+
+
+
+Il compilatore di Rust non compila con le ottimizzazioni se non esplicitamente istruito [considerato che le ottimizzazioni rallentano la compilazione e sono scosigliate durante lo sviluppo](https://users.rust-lang.org/t/why-does-cargo-build-not-optimise-by-default/4150/3).
+
+Se compili con `cargo` usa il parametro `--release`.
+Se compili direttamente con `rustc`, usa il parametro `-O`.
+Ciascuno di questi abiliterá le ottimizzazioni.
+
+
+
+Principalmente per la traduzione del codice e le ottimizzazioni.
+Rust fornisce delle astrazioni ad alto livello che vengono compilate in un codice macchina efficiente e queste trasformazioni richiedono molto tempo per essere effettuate, specialmente se in combinazione con le ottimizzazioni.
+
+Ma il tempo di compilazione di Rust non é male come sembra e c'é da essere fiduciosi in un suo miglioramento futuro.
+Comparando progetti di dimensioni simili tra il C++ e Rust il tempo di compilazione é generalmente comparabile.
+La percezione di lentezza é largamente dovuta alle differenze tra il *modello di compilazione* del C++ da quello di Rust, l'unitá base del C++ é il file mentre in Rust é l'intero pacchetto, composto da molti file.
+Di conseguenza durante lo sviluppo la modifica di un file causa molta meno ricompilazione che in Rust.
+In questo momento é in corso uno sforzo per implementare una ristrutturazione del compilatore che permetta di effettuare la
+[compilazione incrementale](https://github.com/rust-lang/rfcs/blob/master/text/1298-incremental-compilation.md), che consentirá a Rust di implementare un modello piú rapido e simile al C++.
+
+Oltre al modello di compilazione, ci sono molti altri aspetti dell'implementazione di Rust e il suo compilatore che ne impattano le prestazioni in fase di compilazione.
+
+Inizialmente, Rust has un sistema di tipi moderatamente complesso e deve spendere un discreto quantitativo di tempo durante la compilazione a verificarne limitazioni e utilizzi, rendendo Rust sicuro durante la sua esecuzione.
+
+Secondariamente, il compilatore di Rust soffre di un debito tecnico di lunga data e risaputamente genera una rappresentazione intermedia per LLVM di bassa qualitá a cui LLVM deve porre rimedio.
+Si spera che i futuri passaggi di trasformazione e ottimizzazione [basati su MIR](https://github.com/rust-lang/rfcs/blob/master/text/1211-mir.md) riducano la quantitá di lavoro che Rust impone a LLVM.
+
+Terziariamente, l'utilizzo da parte di Rust di LLVM per la generazione del codice macchina é una spada a doppio taglio: se da un lato questo permette a Rust di avere prestazioni degne di nota,
+LLVM é un insieme di strumenti non focalizzato alla velocitá di compilazione, specialmente con input di bassa qualitá.
+
+Inoltre, mentre la strategia preferita da Rust per monomorfizzare i generici (simil C++) produca codice performante, domanda di generare molto piú codice rispetto ad altre strategie di implementazione.
+I programmatori Rust possono utilizzare i tratti per rimuovere questo codice extra e utilizzando un dispacciamento dinamico.
+
+
+
+Di base, le [`HashMap`][HashMap] di Rust utilizzano l'algoritmo di hashing [SipHash](https://131002.net/siphash/), progettato per prevenire [attacchi basati sulla collisione di hash](http://programmingisterrible.com/post/40620375793/hash-table-denial-of-service-attacks-revisited) fornendo comunque [un livello di prestazione accettabile in una varietá di compiti](https://www.reddit.com/r/rust/comments/3hw9zf/rust_hasher_comparisons/cub4oh6).
+
+Mentre SipHash [dimostra prestazioni competitive](http://cglab.ca/%7Eabeinges/blah/hash-rs/) in molti casi, un caso in cui é conclamatamente lento é in presenza di chiavi corte, come ad esempio i numeri interi.
+Questo é perché i programmatori Rust spesso incontrano problemi prestazionali con [`HashMap`][HashMap].
+[FNV hasher](https://crates.io/crates/fnv) é spesso consigliato per queste casistiche, tenendo comunque in considerazione che non possiede le stesse caratteristiche di protezione dagli attacchi a collisione di SipHash.
+
+
+
+Esiste ma é riservata al canale di rilascio "nightly".
+Progettiamo di costituire un sistema integrato e modulare di misurazione delle prestazioni ma nel frattempo il sistema attuale é [considerato instabile](https://github.com/rust-lang/rust/issues/29553).
+
+
+
+In generale, no.
+Le ottimizzazioni delle tail-call sono riservate ad alcune [condizioni particolari](http://llvm.org/docs/CodeGenerator.html#sibling-call-optimization)
+ma [non é assicurato](https://mail.mozilla.org/pipermail/rust-dev/2013-April/003557.html).
+Siccome é sempre stata una funzionalitá desiderata, Rust ha riservato l'identificatore (`become`),
+anche se non é ancora chiaro se sia possibile questa ottimizzazione o se verrá implementata.
+Era stata [proposta un'estensione](https://github.com/rust-lang/rfcs/pull/81) che avrebbe permesso di eliminare le tail-call in alcuni casi ma al momento é stata rimandata.
+
+
+
+Non nel senso tipico utilizzato da linguaggi come il Java ma componenti della libreria standard di Rust possono essere considerati un "ambiente di esecuzione", fornendo controlli per heap, backtrace, unwinding, e stack.
+C'é un piccolo quantitativo [di codice di inizializzazione](https://github.com/rust-lang/rust/blob/33916307780495fe311fe9c080b330d266f35bfb/src/libstd/rt.rs#L43) che viene eseguito prima della funzione `main`.
+La libreria standard di Rust inoltre é collegata alla libreria standard del C, che effettua una simile [inizializzazione](http://www.embecosm.com/appnotes/ean9/html/ch05s02.html).
+Il codice di Rust puó essere compilato anche senza la libreria standard, in questo caso il suo ambiente é circa equivalente a quello del C.
+
+
+
+L'utilizzo delle graffe per indicare blocchi di codice é una scelta comune in una moltitudine di linguaggi di programmazione e l'adesione di Rust allo standard é utile per le persone giá familiari con lo stile.
+
+Le graffe consentono inoltre una sintassi piú flessibile per il programmatore e per un preprocessore piú semplice nel compilatore.
+
+
+
+Mentre il C richiede parentesi obbligatorie per le condizioni dell'istruzione `if` ma rende le parentesi del corpo opzionali,
+Rust fa la scelta opposta per i suoi `if`.
+Questo lascia la condizione separata chiaramente dal corpo e evita il pericolo delle parentesi opzionali,
+che possono condurre in inganno durante la modifica del codice, come il famoso errore [goto fail](https://gotofail.com/) commesso da Apple.
+
+
+
+Le scelte stilistiche di Rust sono per limitare la dimensione del *linguaggio* contemporaneamente sfruttando potenti *librerie*.
+Anche se Rust fornisce una sintassi per inizializzare array e costanti letterali stringa, questi sono gli unici tipi collezione inseriti nel linguaggio.
+Tutti gli altri tipi definiti da librerie, incluso l'onnipresente [`Vec`][Vec] utilizzano macro per la loro inizializzazione, ad esempio la macro [`vec!`][VecMacro].
+
+La scelta di utilizzare le macro di Rust per facilitare l'inizializzazione di collezioni verrá probabilmente estesa a altre collezioni in futuro, permettendo inizializzazioni semplici non solo di
+[`HashMap`][HashMap] e [`Vec`][Vec], ma anche altri tipi di collezioni come [`BTreeMap`][BTreeMap].
+Nel frattempo, se vuoi una sintassi piú comoda per inizializzare le collezioni, puoi [creare la tua macro](https://stackoverflow.com/questions/27582739/how-do-i-create-a-hashmap-literal) per fornirla.
+
+
+
+Rust é un linguaggio molto espression-centrico e i ritorni impliciti fanno parte del suo design.
+Costrutti come gli `if`, i `match`e i normali blocchi sono tutte espressioni in Rust.
+
+Ad esempio, il codice seguente controlla se un [`i64`][i64] é dispari, ritornando il risultato semplicamente fornendone il risultato:
+
+```rust
+fn dispari(x: i64) -> bool {
+ if x % 2 != 0 { true } else { false }
+}
+```
+
+Anche se puó essere ulteriormente semplificato come qui:
+
+
+```rust
+fn dispari(x: i64) -> bool {
+ x % 2 != 0
+}
+```
+
+In ciascun esempio, l'ultima riga rappresenta il valore di ritorno della funzione.
+Risulta importante specificare che se una funzione termina con un punto e virgola il suo tipo di ritorno sará `()`, indicando nessun valore di ritorno.
+I ritorni impliciti funzionano quindi esclusivamente in assenza del punto e virgola.
+
+I ritorni espliciti sono utilizzati solo se un ritorno implicito risulta impossibile perché si desidera ritornare un valore prima della fine del corpo della funzione.
+Mentre ciascuna delle funzioni sopra avrebbe potuto includere un `return` e un punto e virgola, questa aggiunta sarebbe inutilmente prolissa e inconsistente con le convenzioni del codice Rust.
+
+
+
+In Rust le dichiarazioni sono tendelzialmente accompagnate da un tipo esplicito, mentre nel codice i tipi vengono dedotti.
+Ci sono multiple ragioni per questa scelta:
+
+- Dichiarazioni obbligatorie dei tipi obbligano a mantenere un'interfaccia stabile a livello di modulo e di pacchetto.
+- I tipi facilitano la comprensione del codice per il programmatore, eliminando la necessitá di un ambiente di sviluppo che possa desumere il tipo analizzando il codice dell'intero pacchetto:
+il tipo é sempre disponibile nelle vicinanze e in modo esplicito.
+- Semplifica gli algoritmi che gesticono la deduzione dei tipi, visto che puó essere analizzata una funzione alla volta.
+
+
+
+Per assistere nelle modifiche e in chiarezza.
+
+Prima di tutto, se ogni possibilitá viene coperta da un `match`, l'aggiunta di varianti a un `enum` causerá un errore di compilazione, invece che un problema durante l'esecuzione.
+Questo tipo di assistenza permette di modificare il codice Rust liberamente e senza paura.
+
+Secondariamente, il controllo dettagliato rende esplicito il caso predefinito: in generale l'unico modo per creare un `match` non esaustivo sarebbe di far andare in errore il processo se non viene incontrato alcun valore previsto.
+Le versioni iniziali di Rust non prevedevano la completezza di `match` ed é stato accertato che questa scelta ha causato una moltitudine di problematiche.
+
+
+Risulta comunque semplice ignorare tutti i casi non specificati usando il carattere speciale `_`:
+
+```rust
+match val.fai_qualcosa() {
+ Gatto(a) => { /* ... */ }
+ _ => { /* ... */ }
+}
+```
+
+
+
+La scelta dipende dallo scopo del programma.
+
+Se ció che conta é la precisione massima, [`f64`][f64] é da preferire.
+Se invece si vuole minimizzare l'impatto in memoria e l'efficienza, ignorando la precisione persa, [`f32`][f32] é piú appropriato.
+Svolgere operazioni sugli [`f32`][f32] é generalmente piú veloce, anche in piattaforme a 64-bit.
+Come esempio, la grafica sfrutta tipicamente gli [`f32`][f32] perché richiede alte prestazioni e i numeri in virgola mobile a 32-bit bastano per rappresentare i pixel a schermo.
+
+Nel dubbio, scegli [`f64`][f64] per una maggiore precisione.
+
+
+
+I numeri a virgola mobile si possono comparare con gli operatori `==`, `!=`, `<`, `<=`, `>`, e `>=` , e attraverso la funzione `partial_cmp()`.
+`==` e `!=` possiedono il tratto [`PartialEq`][PartialEq], mentre `<`, `<=`, `>`, `>=`, e `partial_cmp()` possiedono il tratto [`PartialOrd`][PartialOrd].
+
+I numeri a virgola mobile non sono confrontabili con la funzione `cmp()`, possidente il tratto [`Ord`][Ord], dato che i numeri a virgola mobile non costituiscono insieme totalmente ordinato.
+Inoltre non esiste relazione di uguaglianza completa numeri a virgola mobile e quindi non implementano il tratto[`Eq`][Eq].
+
+Non esiste l'ordinamento totale o l'uguaglianza tra numeri a virgola mobile a causa del valore [`NaN`](https://en.wikipedia.org/wiki/NaN) che non é minore, maggiore o uguale di alcun altro numero o sé stesso.
+
+Visto che i numeri a virgola mobile non implementano i tratti [`Eq`][Eq] o [`Ord`][Ord], non sono utilizzabili nei tipi le cui limitazioni esigono l'implementazione di queste caratteristiche, come [`BTreeMap`][BTreeMap] o [`HashMap`][HashMap].
+Questo é importante perché questi tipi *suppongono* che le chiavi forniscano relazioni di ordinamento totale o di uguaglianza, a pena di malfunzionamenti.
+
+Esiste [un pacchetto](https://crates.io/crates/ordered-float) che racchiude [`f32`][f32] e [`f64`][f64] in modo da fornire i tratti [`Ord`][Ord] e [`Eq`][Eq] che potrebbe assistere in certi casi.
+
+
+
+Ci sono due modi: la parola chiave `as`, che esegue una semplice conversione per tipi primitivi e i tratti [`Into`][Into] e [`From`][From],
+che sono implementati per una serie di conversioni tra tipi numerici (e che anche tu puoi implementare sui tuoi tipi).
+I tratti [`Into`][Into] e [`From`][From] sono implementati esclusivamente per le conversioni prive di perdita, qundi ad esempio, `f64::from(0f32)` funziona mentre `f32::from(0f64)` no.
+D'altro canto, `as` convertirá tra qualsiasi coppia di tipi primitivi, effettuando i necessari troncamenti..
+
+
+
+
+Gli operatori di preincremento e postincremento (e relativi opposti equivalenti), anche se convenienti presentano una discreta complessitá;
+Richiedono una conoscenza dell'ordine di esecuzione e spesso conducono a piccoli problemi e comportamenti anormali in C e C++.
+`x = x + 1` o `x += 1` é leggermente piú prolisso ma chiaro.
+
+
+
+Solitamente, puoi passare un riferimento a una `String` o ad un `Vec` ovunque ci si aspetti una partizione.
+Utilizzando le [costrizione da de-riferimento](https://doc.rust-lang.org/stable/book/deref-coercions.html), [`String`][String] e [`Vec`][Vec] verrano automaticamente ridotti alle rispettive partizioni quando passate come riferimento tramite `&` o `& mut`.
+
+I metodi implementati su `&str` e `&[T]` possono essere utilizzati direttamente su `String` e `Vec`.
+Ad esempio `una_stringa.char_at(0)` funzionerá anche se `char_at` é un metodo su `&str` e `una_stringa` é una `String`.
+
+In alcuni casi, come nella programmazione generica é necessario convertire manualmente, questa operazione é effettuabile utilizzando l'operatore di partizione, in questo modo: `&mio_vettore[..]`.
+
+
+
+Il metodo [`to_string()`][to_string] converte una [`&str`][str] in una [`String`][String] e le [`String`][String] sono automaticamente convertite in [`&str`][str] quando ne acquisisci un riferimento.
+Entrambe sono visibili nell'esempio seguente:
+
+```rust
+fn main() {
+ let s = "Maria Rossi".to_string();
+ saluta(&s);
+}
+
+fn saluta(nome: &str) {
+ println!("Ciao {}!", nome);
+}
+```
+
+
+
+[`String`][String] é un'area di memoria allocata nel heap di byte UTF-8.
+Le [`String`][String] mutabili possono essere modificate, espanendosi se necessario.
+[`&str`][str] é una "vista" di capacitá fissata in una [`String`][String] allocata altrove, generalmente nel heap, in caso di partizioni riferite a [`String`][String], o in memoria statica, per le costanti letterali.
+
+[`&str`][str] é un tipo primitivo implementato nel linguaggio Rust, mentre [`String`][String] é implementato dalla libreria standard.
+
+
+
+Non é possibile. Senza una chiara comprensione di cosa intendi per "carattere" e una pre-elaborazione della stringa per ritrovare l'indice del carattere desiderato.
+
+Le stringhe in Rust sono codificate in UTF-8.
+Un singolo carattere UTF-8 non é obbligatoriamente grande un singolo byte come sarebbe una stringa codificata in ASCII.
+Ogni byte é chiamato una "unitá di codice" (nello UTF-16, le unitá di codice sono di 2 byte, nello UTF-32 sono di 4 byte).
+I "punti di codice" sono composti di una o piú unitá di codice, combinate in "gruppi di grafemi" che fedelmente ricalcano il concetto tradizionale di caratteri.
+
+Anche con la possibilitá di indicizzare i byte in una stringa UTF-8, non puoi accedere all'`i`-esimo elemento del gruppo di grafemi in un tempo costante.
+Ad ogni modo, se conosci a quale byte si trova il punto di codice o gruppo di grafemi desiderato, quindi _puoi_ accedervi in tempo costante.
+Le funzioni, incluse [`str::find()`][str__find] e le espressioni regolari ritornano indici dei byte, facilitando questo tipo di accesso.
+
+
+
+Le [`str`][str] sono UTF-8 perché nel mondo questa codifica é frequente - specialmente in trasmissioni di rete, che ignorano l'ordine di bit della piattaforma - pensiamo quindi sia meglio che il trattamento standard dell'I/O non preveda la ricodifica in entrambe le direzioni.
+
+Questo significa che individuare un particolare punto di codice Unicode dentro una stringa é un'operazione O(n), anche se, conoscendo l'indice del byte ci si puó accedere in un tempo O(1) come previsto.
+Sotto un certo punto di vista questo é chiaramente sconveniente; ma d'altro canto questo problema é pieno di compromessi e vorremmo sottolineare alcune precisazioni importanti:
+
+Scorrere una [`str`][str] per valori della codifica ASCII puó essere fatto in sicurezza byte per byte,
+utilizzando [`.as_bytes()`][str__as_bytes] ed estraendo [`u8`][u8] con un costo `O(1)` e producendo valori che possono essere trasformati e comparati con la codifica ASCII con il tipo [`char`][char].
+Quindi se per (ad esempio) vogliamo andare a capo ad ogni `'\n'`, una ricerca byte a byte continua a essere funzionante, grazie alla flessibilitá dello standard UTF-8.
+
+La maggior parte delle operazioni orientate ai caratteri sul testo funzionano su presupposti molto ristretti come ad esempio l'esclusione dei caratteri non ASCII.
+Anche in questo caso all'esterno della codifica ASCII si tende a utilizzare comunque un algoritmo complesso(con complessitá non costante) per determinare i bordi di caratteri, parole e paragrafi.
+Noi consigliamo di utilizzare un algoritmo "onesto", approvato da Unicode e adattato al linguaggio da considerare.
+
+Il tipo [`char`][char] é UTF-32.
+Se hai la certezza di dover richiedere l'analisi di un "punto di codice" alla volta é semplicissimo scrivere `type wstr = [char]` e caricarci dentro una [`str`][str] in un solo passaggio, per poi lavorare con il nuovo `wstr`.
+In altre parole: il fatto che il linguaggio non decodifichi a UTF32 come prima opzione non ti deve inibire da decodificare(o ri-codificare per il processo inverso) i caratteri se necessiti di lavorare in quella codifica.
+
+Per una spiegazione piú dettagliata su perché UTF-8 é preferibile rispetto a UTF-16 o UTF-32, leggi il [manifesto di UTF-8 Everywhere](http://utf8everywhere.org/).
+
+
+
+Rust ha quattro paia di tipi stringa, [ciascuno assolve un ruolo distinto](http://www.suspectsemantics.com/blog/2016/03/27/string-types-in-rust/).
+In ciascun paio, c'é un tipo stringa "posseduto" e un tipo stringa "partizione".
+I tipi sono suddivisi cosí:
+
+| | tipo "Partizione" | tipo "Posseduto" |
+|:----------------------|:------------------|:-----------------|
+| UTF-8 | `str` | `String` |
+| Compatibile con il SO | `OsStr` | `OsString` |
+| Compatibile con il C | `CStr` | `CString` |
+| Percorso di sistema | `Path` | `PathBuf` |
+
+I diversi tipi di stringa di Rust assolvono ruoli diversi.
+`String` e `str` sono stringhe ad uso generico codificate in in UTF-8.
+`OsString` e `OsStr` sono codificati a seconda della piattaforma corrente e sono utilizzati per interagire con il sistema operativo.
+`CString` e `CStr` sono l'equivalente in Rust delle stringhe del C, si utilizzano nelle chiamate FFI, mentre `PathBuf` e `Path` sono un'aggiunta di `OsString` e `OsStr` ed implementano metodi specifici alla manipolazione di percorsi.
+
+
+
+Ci sono diverse opzioni, a seconda delle necessitá della funzione:
+
+- Se la funzione richiede una stringa posseduta ma vuole accettare una qualsiasi stringa utilizza la restrizione al tratto `Into`.
+- Se la funzione richiede una partizione di stringa ma vuole accettare una qualsiasi stringa utilizza la restrizione al tratto `AsRef`.
+- Se alla funzione non interessa del tipo di stringa e vuole gestire uniformemente le due possibilitá utilizza il tipo `Cow.`
+
+__Usare `Into`__
+
+In questo esempio, la funzione accetta sia stringhe possedute che partizioni di stringa o facendo nulla o convertendo l'ingresso in stringa posseduta.
+Nota che la conversione deve essere fatta esplicitamente e non succede altrimenti.
+
+```rust
+fn accetta_entrambe>(s: S) {
+ let s = s.into(); // Questo converte s in una `String`.
+ // ... il resto della funzione
+}
+```
+
+__Usare `AsRef`__
+
+In questo esempio, la funzione accetta sia stringhe possedute che partizioni di stringa o facendo nulla o convertendo l'ingresso in una partizione di stringa.
+Questo viene fatto automaticamente prendendo l'ingresso per riferimento, come qui:
+
+```rust
+fn accetta_entrambe>(s: &S) {
+ // ... il corpo della funzione
+}
+```
+
+__Usare `Cow`__
+
+In questo esempio, la funzione accetta un `Cow`, che non é un tipo generico ma un contenitore, contenente o una stringa posseduta o una partizione di stringa all'occorrenza.
+
+```rust
+fn accetta_cow(s: Cow) {
+ // ... il corpo della funzione
+}
+```
+
+
+
+
+If vuoi implementare queste strutture dati per utilizzarle in altri programmi non é necessario, essendo implementazioni efficienti di queste strutture giá disponibili nella libreria standard.
+
+Se invece, [vuoi solo imparare](http://cglab.ca/~abeinges/blah/too-many-lists/book/), probabilmente dovrai entrare nel codice insicuro.
+Anche se é _possibile_ implementarle solo con codice sicuro, le prestazioni sarebbero probabilmente peggiori di come sarebbe stato lo stesso codice con l'utilizzo di codice insicuro.
+La semplice ragione per ció é che le strutture dati come vettori e liste concatenate fanno affidamento a operazioni su puntatori e memoria che sono proibiti nel Rust sicuro.
+
+Per esempio, una lista concatenata doppia richiede due riferimenti mutabili a ciascun nodo ma questo viola le regole di Rust sull'esclusivitá dei riferimenti mutabili.
+Si puó risolvere il problema utilizzando [`Weak`][Weak], ma le prestazioni sarebbero probabilmente peggiori di quanto desiderato.
+Con il codice insicuro puoi ignorare le regole di esclusivitá ma devi verificare manualmente che il tuo codice non introduca violazioni nella sua gestione della memoria.
+
+
+
+Il modo piú semplice é utilizzare l'implementazione del tratto [`IntoIterator`][IntoIterator].
+Ecco qui un esempio con [`&Vec`][Vec]:
+
+```rust
+let v = vec![1,2,3,4,5];
+for oggetto in &v {
+ print!("{} ", oggetto);
+}
+println!("\nLunghezza: {}", v.len());
+```
+
+I cicli `for` in Rust chiamano la funzione `into_iter()` (definita dal tratto [`IntoIterator`][IntoIterator]) per qualsiasi cosa stiano analizzando.
+Tutto ció che implementa il tratto [`IntoIterator`][IntoIterator] puó essere traversato con un ciclo `for`.
+[`IntoIterator`][IntoIterator] é implementato per [`&Vec`][Vec] e [`&mut Vec`][Vec], obbligando l'iteratore generato da `into_iter()` a prendere in prestito i contenuti della collezione, al posto di consumarli o muoverli.
+Lo stesso é vero per le altre collezioni della libreria standard.
+
+Se si desidera un iteratore che muova/consumi i valori, basta scrivere lo stesso ciclo `for` omettendo `&` o `&mut`.
+
+Se si necessita accesso diretto all'iteratore, vi si puó usualmente accedere invocando il metodo `iter()`.
+
+
+
+Non é necessario. Se dichiari direttamente un vettore, la dimensione é dedotta dal numero di elementi. Se invece dichiari una funzione che accetta un vettore di dimensione prefissata il compilatore deve avere modo di sapere quale sará la dimensione di quel vettore.
+
+Una cosa da notare é che attualmente Rust non offere generici su array di dimensioni diverse.
+Se desideri quindi accettare un contenitore continuo di un numero variabile di valori, utilizza [`Vec`][Vec] o una partizione (a seconda che tu richieda il possesso o no).
+
+
+
+Esistono almeno quattro diverse opzioni (largamente discusse in [Too Many Linked Lists](http://cglab.ca/~abeinges/blah/too-many-lists/book/)):
+
+- Puoi implementarlo usando [`Rc`][Rc] e [`Weak`][Weak] per permettere il possesso condiviso dei nodi,
+anche se questo approccio richiede la gestione della memoria.
+- Puoi implementarlo usando codice `unsafe` e i puntatori.
+Anche se efficiente questo metodo ignora i paradigmi di sicurezza di Rust.
+- Usando vettori indici al loro interno. Esistono [diversi](http://smallcultfollowing.com/babysteps/blog/2015/04/06/modeling-graphs-in-rust-using-vector-indices/) modi [disponibili](https://featherweightmusings.blogspot.com/2015/04/graphs-in-rust.html), esempi e spiegazioni di questo metodo.
+- Usando [`UnsafeCell`][UnsafeCell]. Esistono [spiegazioni e codice](https://github.com/nrc/r4cppp/blob/master/graphs/README.md#node-and-unsafecell) per questo metodo.
+
+
+
+Si puó fare ma é inutile.
+La struttura diventa permanentemente prestata a sé stessa e quindi non puó essere copiata.
+Ecco del codice per capire meglio:
+
+```rust
+use std::cell::Cell;
+
+#[derive(Debug)]
+struct Immobile<'a> {
+ x: u32,
+ y: Cell