Merge branch 'master' into patch-2

14 files changed, 1591 insertions, 326 deletions

diff --git a/it-it/asciidoc-it.html.markdown b/it-it/asciidoc-it.html.markdown
index 47a57349..eaa2372b 100644
--- a/it-it/asciidoc-it.html.markdown
+++ b/it-it/asciidoc-it.html.markdown
@@ -6,7 +6,7 @@ contributors:
 translators:
     - ["Ale46", "https://github.com/ale46"]
 lang: it-it
-filename: asciidoc-it.md
+filename: asciidoc-it.adoc
 ---
 
 AsciiDoc è un linguaggio di markup simile a Markdown e può essere usato per qualsiasi cosa, dai libri ai blog. Creato nel 2002 da Stuart Rackman, questo linguaggio è semplice ma permette un buon numero di personalizzazioni.
diff --git a/it-it/c++-it.html.markdown b/it-it/c++-it.html.markdown
index 449aebfb..a8e0c7b5 100644
--- a/it-it/c++-it.html.markdown
+++ b/it-it/c++-it.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: c++
+language: C++
 filename: learncpp-it.cpp
 contributors:
     - ["Steven Basart", "http://github.com/xksteven"]
diff --git a/it-it/elixir-it.html.markdown b/it-it/elixir-it.html.markdown
index 48afe0c8..ce3e4535 100644
--- a/it-it/elixir-it.html.markdown
+++ b/it-it/elixir-it.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: elixir
+language: Elixir
 contributors:
     - ["Luca 'Kino' Maroni", "https://github.com/kino90"]
     - ["Joao Marques", "http://github.com/mrshankly"]
@@ -21,11 +21,11 @@ e molte altre funzionalità.
 # Non esistono commenti multilinea,
 # ma puoi concatenare più commenti.
 
-# Per usare la shell di elixir usa il comando `iex`.
+# Per usare la shell di Elixir usa il comando `iex`.
 # Compila i tuoi moduli con il comando `elixirc`.
 
 # Entrambi i comandi dovrebbero già essere nel tuo PATH se hai installato
-# elixir correttamente.
+# Elixir correttamente.
 
 ## ---------------------------
 ## -- Tipi di base
@@ -87,7 +87,7 @@ multi-linea.
 <<?a, ?b, ?c>> #=> "abc"
 [?a, ?b, ?c]   #=> 'abc'
 
-# `?a` in elixir restituisce il valore ASCII della lettera `a`
+# `?a` in Elixir restituisce il valore ASCII della lettera `a`
 ?a #=> 97
 
 # Per concatenare liste si usa `++`, per binari si usa `<>`
@@ -112,7 +112,7 @@ minore..maggiore = 1..10 # Puoi fare pattern matching anche sugli intervalli
 5 * 2  #=> 10
 10 / 2 #=> 5.0
 
-# In elixir l'operatore `/` restituisce sempre un decimale.
+# In Elixir l'operatore `/` restituisce sempre un decimale.
 
 # Per fare una divisione intera si usa `div`
 div(10, 2) #=> 5
@@ -173,7 +173,7 @@ else
 end
 
 # Ti ricordi il pattern matching?
-# Moltre strutture di controllo di flusso in elixir si basano su di esso.
+# Moltre strutture di controllo di flusso in Elixir si basano su di esso.
 
 # `case` ci permette di confrontare un valore a diversi pattern:
 case {:uno, :due} do
@@ -307,7 +307,7 @@ Geometria.area({:cerchio, 3})       #=> 28.25999999999999801048
 # Geometria.area({:cerchio, "non_un_numero"})
 #=> ** (FunctionClauseError) no function clause matching in Geometria.area/1
 
-# A causa dell'immutabilità dei dati, la ricorsione è molto frequente in elixir
+# A causa dell'immutabilità dei dati, la ricorsione è molto frequente in Elixir
 defmodule Ricorsione do
   def somma_lista([testa | coda], accumulatore) do
     somma_lista(coda, accumulatore + testa)
@@ -382,7 +382,7 @@ end
 ## ---------------------------
 
 # Elixir si basa sul modello degli attori per la concorrenza.
-# Tutto ciò di cui abbiamo bisogno per scrivere programmi concorrenti in elixir
+# Tutto ciò di cui abbiamo bisogno per scrivere programmi concorrenti in Elixir
 # sono tre primitive: creare processi, inviare messaggi e ricevere messaggi.
 
 # Per creare un nuovo processo si usa la funzione `spawn`, che riceve una
@@ -434,7 +434,7 @@ self() #=> #PID<0.27.0>
 
 ## Referenze
 
-* [Getting started guide](http://elixir-lang.org/getting_started/1.html) dalla [pagina web ufficiale di elixir](http://elixir-lang.org)
+* [Getting started guide](http://elixir-lang.org/getting_started/1.html) dalla [pagina web ufficiale di Elixir](http://elixir-lang.org)
 * [Documentazione Elixir](https://elixir-lang.org/docs.html)
 * ["Programming Elixir"](https://pragprog.com/book/elixir/programming-elixir) di Dave Thomas
 * [Elixir Cheat Sheet](http://media.pragprog.com/titles/elixir/ElixirCheat.pdf)
diff --git a/it-it/go-it.html.markdown b/it-it/go-it.html.markdown
index 797f6b0b..6f974c91 100644
--- a/it-it/go-it.html.markdown
+++ b/it-it/go-it.html.markdown
@@ -34,7 +34,7 @@ Go include un'ottima libreria standard e ha una community entusiasta.
  su riga multipla */
 
 // In cima ad ogni file è necessario specificare il package.
-// Main è un package speciale che identifica un eseguibile anziché una libreria.
+// main è un package speciale che identifica un eseguibile anziché una libreria.
 package main
 
 // Con import sono dichiarate tutte le librerie a cui si fa riferimento 
@@ -91,7 +91,7 @@ può includere andata a capo.` // Sempre di tipo stringa.
     // Stringa letterale non ASCII. I sorgenti Go sono in UTF-8.
 	g := 'Σ' // Il tipo runa, alias per int32, è costituito da un code point unicode.
 
-	f := 3.14195 // float64, un numero in virgola mobile a 64-bit (IEEE-754)
+	f := 3.14159 // float64, un numero in virgola mobile a 64-bit (IEEE-754)
 
 	c := 3 + 4i  // complex128, rappresentato internamente con due float64.
 
@@ -422,9 +422,9 @@ func richiediServer() {
 
 ## Letture consigliate
 
-La risorsa più importante per imparare il Go è il [sito ufficiale di Go](http://golang.org/).
+La risorsa più importante per imparare il Go è il [sito ufficiale di Go](https://go.dev/).
 Qui puoi seguire i tutorial, scrivere codice in modo interattivo, e leggere tutti i dettagli.
-Oltre al tour, [la documentazione](https://golang.org/doc/) contiene informazioni su
+Oltre al tour, [la documentazione](https://go.dev/doc/) contiene informazioni su
 come scrivere ottimo codice in Go, documentazione sui package e sui comandi, e
 la cronologia delle release.
 
@@ -432,17 +432,17 @@ Anche il documento che definisce il linguaggio è un'ottima lettura. E' semplice
 da leggere e incredibilmente corto (rispetto ad altri documenti riguardanti
 la creazione di linguaggi).
 
-Puoi giocare con il codice visto finora nel [Go playground](https://play.golang.org/p/Am120Xe7qf).
+Puoi giocare con il codice visto finora nel [Go playground](https://go.dev/play/p/Am120Xe7qf).
 Prova a cambiarlo e ad eseguirlo dal browser!
-Osserva che puoi usare [https://play.golang.org](https://play.golang.org) come
+Osserva che puoi usare [https://go.dev/play/](https://go.dev/play/) come
 una [REPL](https://en.wikipedia.org/wiki/Read-eval-print_loop) per scrivere
 codice all'interno del browser, senza neanche installare Go!
 
 Una lettura importante per capire Go in modo più profondo è il [codice 
-sorgente della libreria standard](http://golang.org/src/pkg/). Infatti è
+sorgente della libreria standard](https://go.dev/src/). Infatti è
 molto ben documentato e costituisce quanto più chiaro e conciso ci sia riguardo
 gli idiomi e le buone pratiche del Go. Inoltre, clickando sul nome di una
-funzione [nella documentazione](http://golang.org/pkg/) compare il relativo
+funzione [nella documentazione](https://go.dev/pkg/) compare il relativo
 codice sorgente!
 
 Un'altra ottima risorsa per imparare è [Go by example](https://gobyexample.com/).
diff --git a/it-it/markdown.html.markdown b/it-it/markdown.html.markdown
index b0a123f1..609d3bb7 100644
--- a/it-it/markdown.html.markdown
+++ b/it-it/markdown.html.markdown
@@ -72,7 +72,7 @@ __Come pure questo.__
 *__E questo!__*
 ```
 
-In Github Flavored Markdown, che è utilizzato per renderizzare i file markdown su Github, è presente anche lo stile barrato:
+In GitHub Flavored Markdown, che è utilizzato per renderizzare i file markdown su GitHub, è presente anche lo stile barrato:
 
 ```md
 ~~Questo testo è barrato.~~
@@ -183,7 +183,7 @@ Potete inoltre inserire un altro tab (o altri quattro spazi) per indentare il vo
 
 ```md
     my_array.each do |item|
-        puts item
+      puts item
     end
 ```
 
@@ -193,14 +193,17 @@ Codice inline può essere inserito usando il carattere backtick `
 Giovanni non sapeva neppure a cosa servisse la funzione `go_to()`!
 ```
 
-In Github Flavored Markdown, potete inoltre usare una sintassi speciale per il codice
-<pre>
-<code class="highlight">&#x60;&#x60;&#x60;ruby
+In GitHub Flavored Markdown, potete inoltre usare una sintassi speciale per il codice
+
+````md
+```ruby
 def foobar
-    puts "Hello world!"
+  puts "Hello world!"
 end
-&#x60;&#x60;&#x60;</code></pre>
-Se usate questa sintassi, il testo non richiederà di essere indentato, inoltre Github userà l'evidenziazione della sintassi del linguaggio specificato dopo i \`\`\` iniziali
+```
+````
+
+Se usate questa sintassi, il testo non richiederà di essere indentato, inoltre GitHub userà l'evidenziazione della sintassi del linguaggio specificato dopo i \`\`\` iniziali
 
 ## Linea orizzontale
 Le linee orizzontali (`<hr/>`) sono inserite facilmente usanto tre o più asterischi o trattini, con o senza spazi. 
@@ -253,7 +256,7 @@ Ma non è comunemente usato.
 Le immagini sono inserite come i link ma con un punto esclamativo inserito prima delle parentesi quadre!
 
 ```md
-![Qeusto è il testo alternativo per l'immagine](http://imgur.com/myimage.jpg "Il titolo opzionale")
+![Questo è il testo alternativo per l'immagine](http://imgur.com/myimage.jpg "Il titolo opzionale")
 ```
 
 E la modalità a riferimento funziona esattamente come ci si aspetta
@@ -282,7 +285,7 @@ Voglio inserire *questo testo circondato da asterischi* ma non voglio che venga
 ```
 
 ### Combinazioni di tasti
-In Github Flavored Markdown, potete utilizzare il tag `<kbd>` per raffigurare i tasti della tastiera.
+In GitHub Flavored Markdown, potete utilizzare il tag `<kbd>` per raffigurare i tasti della tastiera.
 
 ```md
 Il tuo computer è crashato? Prova a premere
@@ -290,7 +293,7 @@ Il tuo computer è crashato? Prova a premere
 ```
 
 ### Tabelle
-Le tabelle sono disponibili solo in Github Flavored Markdown e sono leggeremente complesse, ma se proprio volete inserirle fate come segue:
+Le tabelle sono disponibili solo in GitHub Flavored Markdown e sono leggeremente complesse, ma se proprio volete inserirle fate come segue:
 
 ```md
 | Col1                 | Col2     | Col3               |
@@ -307,4 +310,4 @@ Col 1 | Col2 | Col3
 ```
 
 ---
-Per altre informazioni, leggete il post ufficiale di John Gruber sulla sintassi [qui](http://daringfireball.net/projects/markdown/syntax) e il magnifico cheatsheet di Adam Pritchard [qui](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet).
+Per altre informazioni, leggete il post ufficiale di John Gruber sulla sintassi [qui](https://daringfireball.net/projects/markdown/syntax) e il magnifico cheatsheet di Adam Pritchard [qui](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet).
diff --git a/it-it/matlab-it.html.markdown b/it-it/matlab-it.html.markdown
index 38be8848..2668815f 100644
--- a/it-it/matlab-it.html.markdown
+++ b/it-it/matlab-it.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: Matlab
+language: MATLAB
 contributors:
     - ["mendozao", "http://github.com/mendozao"]
     - ["jamesscottbrown", "http://jamesscottbrown.com"]
@@ -114,7 +114,7 @@ A.d.e = false;
 
 % Vettori
 x = [4 32 53 7 1]
-x(2) % ans = 32, gli indici in Matlab iniziano da 1, non da 0
+x(2) % ans = 32, gli indici in MATLAB iniziano da 1, non da 0
 x(2:3) % ans = 32 53
 x(2:end) % ans = 32 53 7 1
 
@@ -466,7 +466,7 @@ perms(x) % lista tutte le permutazioni di elementi di x
 
 
 % Classi
-% Matlab supporta la programmazione orientata agli oggetti.
+% MATLAB supporta la programmazione orientata agli oggetti.
 % La classe deve essere messa in un file con lo stesso nome della classe e estensione .m
 % Per iniziare, creiamo una semplice classe per memorizzare waypoint GPS
 % Inizio WaypointClass.m
@@ -488,7 +488,7 @@ classdef WaypointClass % Il nome della classe.
     end
 
     % Se si vuole aggiungere due oggetti Waypoint insieme senza chiamare
-    % una funzione speciale si può sovradefinire una funzione aritmetica di Matlab come questa:
+    % una funzione speciale si può sovradefinire una funzione aritmetica di MATLAB come questa:
     function r = plus(o1,o2)
       r = WaypointClass([o1.latitude] +[o2.latitude], ...
                         [o1.longitude]+[o2.longitude]);
@@ -500,7 +500,7 @@ end
 % Si può creare un oggetto della classe usando un costruttore
 a = WaypointClass(45.0, 45.0)
 
-% Le proprietà della classe si comportano esattamente come una Struttura Matlab.
+% Le proprietà della classe si comportano esattamente come una Struttura MATLAB.
 a.latitude = 70.0
 a.longitude = 25.0
 
@@ -511,15 +511,15 @@ ans = multiplyLatBy(a,3)
 % non necessita di essere passato al metodo.
 ans = a.multiplyLatBy(a,1/3)
 
-% Le funzioni Matlab possono essere sovradefinite per gestire oggetti.
-% Nel metodo sopra, è stato sovradefinito come Matlab gestisce
+% Le funzioni MATLAB possono essere sovradefinite per gestire oggetti.
+% Nel metodo sopra, è stato sovradefinito come MATLAB gestisce
 % l'addizione di due oggetti Waypoint.
 b = WaypointClass(15.0, 32.0)
 c = a + b
 
 ```
 
-## Di più su Matlab
+## Di più su MATLAB
 
 * Sito ufficiale [http://http://www.mathworks.com/products/matlab/](http://www.mathworks.com/products/matlab/)
 * Forum ufficiale di MATLAB: [http://www.mathworks.com/matlabcentral/answers/](http://www.mathworks.com/matlabcentral/answers/)
diff --git a/it-it/php-composer-it.html.markdown b/it-it/php-composer-it.html.markdown
new file mode 100644
index 00000000..509ec336
--- /dev/null
+++ b/it-it/php-composer-it.html.markdown
@@ -0,0 +1,193 @@
+---
+category: tool
+tool: composer
+contributors:
+    - ["Brett Taylor", "https://github.com/glutnix"]
+translator:
+    - ["Agostino Fiscale", "https://github.com/agostinofiscale"]
+lang: it-it
+filename: LearnComposer-it.sh
+---
+
+[Composer](https://getcomposer.org/) è uno strumento che ti aiuta a gestire le 
+dipendenze in PHP. Ti permette di dichiarare le librerie utilizzate dal tuo 
+progetto e di installarle/aggiornarle per te.
+
+# Installazione
+
+```sh
+# Se installi l'eseguibile in una cartella...
+curl -sS https://getcomposer.org/installer | php
+# ...dovrai utilizzare questo approccio, invocando Composer in questo modo:
+php composer.phar about
+
+# Se installi l'eseguibile nella directory ~/bin/composer
+# Nota: assicurati che ~/bin si trovi nella variabile di ambiente PATH
+curl -sS https://getcomposer.org/installer | php -- --install-dir=~/bin --filename=composer
+```
+
+Gli utenti Windows possono seguire le istruzioni per [installarlo su Windows](https://getcomposer.org/doc/00-intro.md#installation-windows).
+
+## Assicuriamoci che il tutto abbia funzionato correttamente
+
+```sh
+# Controlla la versione e la lista delle opzioni disponibili
+composer
+
+# Ottieni ulteriori informazioni riguardanti le opzioni
+composer help require
+
+# Controlla se Composer ha tutto il necessario per funzionare come si deve
+# e se è aggiornato correttamente all'ultima versione disponibile.
+composer diagnose
+composer diag # alias
+
+# Aggiorna Composer all'ultima versione disponibile
+composer self-update
+composer self # alias
+```
+
+# Cominciamo ad usare Composer
+
+Composer memorizza le dipendenze necessarie nel file `composer.json`.
+Puoi editare questo file manualmente, ma è meglio che lasci che Composer se ne 
+occupi per te.
+
+```sh
+# Crea un nuovo progetto nella cartella attuale
+composer init
+# ti verranno chieste delle domande interrative riguardanti il tuo progetto. 
+# Puoi evitare di rispondere almeno che tu non stia sviluppando altri progetti 
+# che che possano dipendere da questo.
+
+# Se il file composer.json esiste già, scarichera' le dipendenze necessarie
+composer install
+
+# Scarica le dipendenze necessarie per l'ambiente di produzione
+composer install --no-dev
+
+# Aggiunge una dipendenza per l'ambiente di produzione
+composer require guzzlehttp/guzzle
+# automaticamente selezionera' l'ultima versione, la scarichera' e la aggiungera'
+# come dipendenza nell'apposito campo del file composer.json.
+
+composer require guzzlehttp/guzzle:6.0.*
+# scarichera' l'ultima versione disponibile corrispondente al pattern (es. 6.0.2)
+# e lo aggiungera' come dipendenza nell'apposito campo del file composer.json.
+
+composer require --dev phpunit/phpunit:~4.5.0
+# aggiungera' la dipendenza nell'ambiente di sviluppo utilizzando l'ultima versione
+# disponibile nel range >=4.5.0 e < 4.6.0.
+
+composer require-dev phpunit/phpunit:^4.5.0
+# aggiungera' la dipendenza nell'ambiente di sviluppo utilizzando l'ultima versione
+# disponibile nel range >=4.5.0 and < 5.0.
+
+# Per ulteriori dettagli riguardo le versioni, vedi [la documentazione di Composer sulle versioni](https://getcomposer.org/doc/articles/versions.md) per ulteriori dettagli
+
+# Per vedere quali pacchetti sono installabili e quali sono gia' stati installati
+composer show
+
+# Per vedere solo quali pacchetti sono gia' stati installati
+composer show --installed
+
+# Per trovare una dipendenza con 'mailgun' nel suo nome o nella descrizione.
+composer search mailgun
+```
+
+[Packagist.org](https://packagist.org/) è il repository principale per i pacchetti
+di Composer.  Cerca qui pacchetti di terze-parti utili per il tuo progetto.
+
+## `composer.json` vs `composer.lock`
+
+Il file `composer.json` memorizza la versione che si preferisce per ogni dipendenza,
+insieme ad altre informazioni.
+
+Il file `composer.lock` memorizza quale versione è stata scaricata per ogni
+dipendenza. Non editare mai questo file.
+
+Se includi il file `composer.lock` nella tua repository git, ogni sviluppatore
+andra' a installare la versione attualmente utilizzata dal tuo progetto per
+ogni dipendenza. Anche quando una nuova versione è stata rilasciata, Composer 
+andra' a installare la versione registrata nel file lock.
+
+```sh
+# Se vuoi aggiornare tutte le dipendenze all'ultima versione che corrisponde al pattern descritto
+composer update
+
+# Se vuoi scaricare l'ultima versione di una particolare dipendenza:
+composer update phpunit/phpunit
+
+# Se vuoi cambiare la versione di una una dipendenza, potresti dover rimuovere
+# quello attualmente selezionato, per poi richiedere quello corretto successivamente,
+# attraverso i seguenti comandi:
+composer remove --dev phpunit/phpunit
+composer require --dev phpunit/phpunit:^5.0
+
+```
+
+## Autoloader
+
+Composer crea una classe autoloader che puoi richiamare nella tua applicazione.
+Puoi creare instanze delle classi tramite il loro namespace.
+
+```php
+require __DIR__ . '/vendor/autoload.php';
+
+$mailgun = new Mailgun\Mailgun("key");
+```
+
+### PSR-4 Autoloader
+
+Puoi aggiungere i tuoi namespace all'autoloader.
+
+Nel file `composer.json`, aggiungi il campo "autoload":
+
+```json
+{
+  "autoload": {
+    "psr-4": {"Acme\\": "src/"}
+  }
+}
+```
+Questo dira' all'autoloader di controllare ogni risorsa che corrisponde al 
+namespace `\Acme\` all'interno della cartella `src`.
+
+In alternativa puoi usare [PSR-0, una Classmap o una lista di file da includere](https://getcomposer.org/doc/04-schema.md#autoload).
+Inoltre e' possibile anche utilizzare `autoload-dev` dedicato all'ambiente di sviluppo.
+
+Quando aggiungi o modifichi una chiave, dovrai ricompilare l'autoload attraverso:
+
+```sh
+composer dump-autoload
+composer dump # alias
+
+# Ottimizza i pacchetti PSR0 e PSR4 per essere caricati anche con le classmap.
+# Sara' lento, ma migliorera' le performance in produzione.
+composer dump-autoload --optimize --no-dev
+```
+
+# La cache di Composer
+
+```sh
+# Composer utilizzera i pacchetti scaricati anche per i progetti futuri. Per evitare che accada:
+composer clear-cache
+```
+
+# Problemi? 
+
+```sh
+composer diagnose
+composer self-update
+composer clear-cache
+```
+
+## Argomenti che non sono stati (ancora) discussi in questo tutorial
+
+* Creare e distribuire pacchetti personali su Packagist.org o altrove
+* Pre- e post- script hooks: eseguire operazioni quando vengono eseguiti degli eventi
+
+### References
+
+* [Composer - Dependency Manager for PHP](https://getcomposer.org/)
+* [Packagist.org](https://packagist.org/)
diff --git a/it-it/pyqt-it.html.markdown b/it-it/pyqt-it.html.markdown
index 7238dd7b..7b5a98c2 100644
--- a/it-it/pyqt-it.html.markdown
+++ b/it-it/pyqt-it.html.markdown
@@ -14,12 +14,12 @@ lang: it-it
 
 Questo è un adattamento sull'introduzione di C ++ a QT di [Aleksey Kholovchuk] (https://github.com/vortexxx192
 ), alcuni degli esempi di codice dovrebbero avere la stessa funzionalità
-che avrebbero se fossero fatte usando pyqt! 
+che avrebbero se fossero fatte usando pyqt!
 
 ```python
 import sys
 from PyQt4 import QtGui
-	
+
 def window():
 	# Crea un oggetto applicazione
     app = QtGui.QApplication(sys.argv)
@@ -47,7 +47,7 @@ if __name__ == '__main__':
 Per ottenere alcune delle funzionalità più avanzate in **pyqt**, dobbiamo iniziare a cercare di creare elementi aggiuntivi.
 Qui mostriamo come creare una finestra popup di dialogo, utile per chiedere all'utente di confermare una decisione o fornire informazioni
 
-```Python 
+```python
 import sys
 from PyQt4.QtGui import *
 from PyQt4.QtCore import *
@@ -66,7 +66,7 @@ def window():
     w.setWindowTitle("PyQt Dialog")
     w.show()
     sys.exit(app.exec_())
-	
+
 # Questa funzione dovrebbe creare una finestra di dialogo con un pulsante
 # che aspetta di essere cliccato e quindi esce dal programma
 def showdialog():
diff --git a/it-it/qt-it.html.markdown b/it-it/qt-it.html.markdown
index d7469f67..ef829493 100644
--- a/it-it/qt-it.html.markdown
+++ b/it-it/qt-it.html.markdown
@@ -1,7 +1,7 @@
 ---
 category: tool
 tool: Qt Framework
-language: c++
+language: C++
 filename: learnqt-it.cpp
 contributors:
     - ["Aleksey Kholovchuk", "https://github.com/vortexxx192"]
diff --git a/it-it/rst-it.html.markdown b/it-it/rst-it.html.markdown
index a834e899..3885cbd8 100644
--- a/it-it/rst-it.html.markdown
+++ b/it-it/rst-it.html.markdown
@@ -81,11 +81,11 @@ Anche le tabelle più complesse possono essere inserite facilmente (colonne e/o
 
 Esistono diversi modi per creare collegamenti:
 
-- Aggiungendo un underscore dopo una parola: Github_ e aggiungendo l'URL di destinazione dopo il testo (questo metodo ha il vantaggio di non inserire URL non necessari all'interno del testo leggibile).
+- Aggiungendo un underscore dopo una parola: GitHub_ e aggiungendo l'URL di destinazione dopo il testo (questo metodo ha il vantaggio di non inserire URL non necessari all'interno del testo leggibile).
 - Digitando un URL completo: https://github.com/ (verrà automaticamente convertito in un collegamento)
-- Utilizzando una sintassi simile a Markdown: `Github <https://github.com/>`_ .
+- Utilizzando una sintassi simile a Markdown: `GitHub <https://github.com/>`_ .
 
-.. _Github https://github.com/
+.. _GitHub https://github.com/
 
 ```
 
diff --git a/it-it/ruby-it.html.markdown b/it-it/ruby-it.html.markdown
index 295bf28a..1f466cce 100644
--- a/it-it/ruby-it.html.markdown
+++ b/it-it/ruby-it.html.markdown
@@ -650,4 +650,4 @@ Something.new.qux #=> 'qux'
 - [Ruby from other languages](https://www.ruby-lang.org/en/documentation/ruby-from-other-languages/)
 - [Programming Ruby](http://www.amazon.com/Programming-Ruby-1-9-2-0-Programmers/dp/1937785491/) - Una passata [edizione libera](http://ruby-doc.com/docs/ProgrammingRuby/) è disponibile online.
 - [Ruby Style Guide](https://github.com/bbatsov/ruby-style-guide) - A community-driven Ruby coding style guide.
-- [Try Ruby](http://tryruby.org) - Imparare le basi del linguaggio di programmazion Ruby, interattivamente nel browser.
+- [Try Ruby](https://try.ruby-lang.org/) - Imparare le basi del linguaggio di programmazion Ruby, interattivamente nel browser.
diff --git a/it-it/rust-it.html.markdown b/it-it/rust-it.html.markdown
index e4b7c33f..acb8b8ba 100644
--- a/it-it/rust-it.html.markdown
+++ b/it-it/rust-it.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: rust
+language: Rust
 contributors:
     - ["Carlo Milanesi", "http://github.com/carlomilanesi"]
 lang: it-it
@@ -229,7 +229,7 @@ fn main() {
 
     // Ciclo/iterazione con `for`
     let array = [1, 2, 3];
-    for i in array.iter() {
+    for i in array {
         println!("{}", i);
     }
 
diff --git a/it-it/solidity.html.markdown b/it-it/solidity.html.markdown
new file mode 100644
index 00000000..be747e68
--- /dev/null
+++ b/it-it/solidity.html.markdown
@@ -0,0 +1,1069 @@
+---
+language: Solidity
+filename: learnSolidity-it.sol
+contributors:
+  - ["Nemil Dalal", "https://www.nemil.com"]
+  - ["Joseph Chow", ""]
+  - ["Bhoomtawath Plinsut", "https://github.com/varshard"]
+  - ["Shooter", "https://github.com/liushooter"]
+  - ["Patrick Collins", "https://gist.github.com/PatrickAlphaC"]
+translators:
+    - ["Al", "http://github.com/al-ias"]
+lang: it-it
+---
+
+Solidity permette di programmare su [Ethereum](https://www.ethereum.org/), una
+macchina virtuale basata sulla blockchain che consente la creazione e
+l'esecuzione degli smart contract senza che sia richiesta centralizzazione o
+fiducia negli attori coinvolti.
+
+Solidity è un linguaggio di programmazione di contratti tipizzato staticamente e
+ha molte cose in comune con Javascript e C. Come per gli oggetti nella
+programmazione ad oggetti, ogni contratto contiene variabili di stato, funzioni
+e tipi di dato semplici. Tra le funzionalità specifiche dei contratti troviamo
+le clausole (guardie) dei modifier, gli event notifier per i listener, e le
+variabili globali custom.
+
+Come esempi di contratti su Ethereum troviamo sistemi di crowdfunding, voto,
+[finanza decentralizzata](https://defipulse.com/) e aste al buio.
+
+Compiere errori nel codice Solidity può portare a rischi e costi alti, quindi
+bisogna fare attenzione a testare e rilasciare le modifiche lentamente. A
+CAUSA DEI CONTINUI CAMBIAMENTI DI ETHEREUM È IMPROBABILE CHE QUESTO DOCUMENTO
+RESTI AGGIORNATO, QUINDI COSNIGLIAMO DI SEGUIRE LA CHAT ROOM DI SOLIDITY E IL
+BLOG DI ETHEREUM PER TENERSI AGGIORNATI. TUTTO IL CODICE QUI PRESENTE E' FORNITO
+COSÌ COM'È, CON ANNESSI RISCHI SOSTANZIALI DI ERRORI O PATTERN DI PROGRAMMAZIONE
+DEPRECATI. 
+
+A differenza di altri linguaggi, potresti aver bisogno di usare pattern di
+pausing, deprecation e throttling usage per ridurre il rischio. Questo documento
+tratta principalmene la sintassi e quindi esclude molti design pattern in voga.
+
+Visto che Solidity e Ethereum sono in continuo sviluppo, le funzionalità
+sperimentali o beta sono evidenziate e soggette a cambiamenti. Ogni Pull Request
+è ben accetta.
+
+
+# Lavorare con Remix e Metamask
+
+Uno dei modi più semplici di scrivere, distribuire e testare il codice Solidity
+è usare :
+
+1. [L'ambiente di sviluppo online Remix](https://remix.ethereum.org/) 
+2. [Il wallet Metamask](https://metamask.io/).
+
+Per cominciare, [scarichiamo l'estesione per browser di Metamask](https://metamask.io/). 
+
+Una volta installata, potremo iniziare ad usare Remix. Il codice seguente è
+pre-inizializzato, ma prima di addentrarci, diamo un'occhiata a qualche
+trucchetto per iniziare ad usare Remix. Carica tutto il necessario [clickando su questo link](https://remix.ethereum.org/#version=soljson-v0.6.6+commit.6c089d02.js&optimize=false&evmVersion=null&gist=f490c0d51141dd0515244db40bbd0c17&runs=200).
+
+1. Scegli il compilatore per Solidity
+
+![Solidity-in-remix](../images/solidity/remix-solidity.png)
+
+2. Apri il file che si caricherà su quel link
+
+![Solidity-choose-file](../images/solidity/remix-choose-file.png)
+
+3. Compila il file
+
+![Solidity-compile](../images/solidity/remix-compile.png)
+
+4. Fai il deploy
+
+![Solidity-deploy](../images/solidity/remix-deploy.png)
+
+5. Smanetta con i contratti
+
+![Solidity-deploy](../images/solidity/remix-interact.png)
+
+Hai distribuito il tuo primo contratto! Congratulazioni!
+
+Potrai testarlo e smanettare con le funzioni già definite. Dai un'occhiata ai
+commenti per scoprire cosa fanno.
+
+
+## Lavorare su una testnet
+
+Distribuire e testare su una testnet è il modo più accurato per mettere alla
+prova i tuoi smart contract in Solidity. Per farlo procuriamoci prima degli ETH
+di test dalla testnet Kovan.
+
+[Entra in questo Gitter Channel](https://gitter.im/kovan-testnet/faucet) e
+scrivici l'indirizzo del tuo wallet Metamask.
+
+Sul tuo Metamask, dovrai cambiare la testnet in `Kovan`.
+
+![Solidity-in-remix](../images/solidity/metamask-kovan.png)
+
+Riceverai degli Ethereum di test gratuiti. Abbiamo bisogno di Ethereum per
+distribuire degli smart contract su una testnet.
+
+Nell'esempio precedente non avevamo usato una testnet, ma avevamo distribuito
+su un ambiente virtuale fittizio. Quando si lavora su una testnet, possiamo
+davvero monitorare e interagire con i nostri contratti in maniera persistente.
+
+Per distribuire su una testnet, allo step `#4 Fai il deploy`, cambia
+l'`environment` selezionato in `injected web3`. In questo modo verrà usato
+come network su cui fare il deploy qualsiasi network selezionato sul tuo
+Metamask.
+
+![Solidity-in-remix](../images/solidity/remix-testnet.png)
+
+Per ora continua a usare la `Javascript VM` a meno che non ti sia detto di
+cambiarla. Quando distribuisci su una testnet, Metamask aprirà un pop up che
+ti chiederà di "confermare" la transazione. Premi `yes` e dopo un certo lasso
+di tempo, ti apparirà la stessa interfaccia per il contratto nella parte
+inferiore dello schermo.
+
+
+```javascript
+// Iniziamo con un semplice contratto su una Banca
+// Permette di depositare, prelevare e fare l'estratto conto
+
+// simple_bank.sol (nota l'estensione .sol)
+/* **** INIZIO DELL'ESEMPIO **** */
+
+// Dichiara la versione del compilatore per il file sorgente
+pragma solidity ^0.6.6;
+
+// Inizia con il commento Natspec (i tre slash)
+// viene usato per la documentazione - e per i dati descrittivi per gli elementi
+// dell'interfaccia utente / azioni
+
+/// @title SimpleBank
+/// @author nemild
+
+/* 'contract' somiglia a 'class' in altri linguaggi (ha variabili di classe,
+ereditarietà, etc.) */
+contract SimpleBank { // CapWords
+    // Dichiariamo le variabili di stato fuori dalle funzioni, persisteranno
+    // durante tutta la vita del contratto
+
+    // i dizionari mappano gli indirizzi con i saldi
+    // fai sempre attenzione agli overflow attack che sfruttano i numeri
+    mapping (address => uint) private balances;
+
+    // "private" significa che che altri contratti non possono leggere i
+    // saldi ma le informazioni restano visibili ad altri attori sulla blockchain
+
+    address public owner;
+    // 'public' lo rende leggibile dall'esterno (ma non modificabile) dagli
+    // utenti e dai contratti
+
+    // Gli 'event' pubblicano le azioni in modo che siano ascoltabili da
+    // listener esterni
+    event LogDepositMade(address accountAddress, uint amount);
+
+    // I 'constructor' possono ricevere uno o più parametri; Si può
+    // dichiarare un solo costruttore
+    constructor() public {
+        // 'msg' fornisce i dettagli sul messaggio che è stato mandato al contratto
+        // 'msg.sender' è chi invoca il contratto (l'indirizzo di chi lo crea)
+        owner = msg.sender;
+    }
+
+    /// @notice Deposita ether nella banca
+    /// @return Il saldo dell'utente dopo che è stato effettualto il deposito
+    function deposit() public payable returns (uint) {
+        // Usiamo 'require' per testare gli input dell'utente, 'assert' per gli
+        // invarianti interni. Qui ci assicuriamo di non avere a che fare con
+        // un overflow
+        require((balances[msg.sender] + msg.value) >= balances[msg.sender]);
+
+        balances[msg.sender] += msg.value;
+        // Non servono "this." o "self." con le variabili di stato
+        // Tutti i valori iniziali delle variabili sono impostati automaticamente
+        // al valore di default per quel tipo di dato
+
+        emit LogDepositMade(msg.sender, msg.value); // Fa scattare l'evento
+
+        return balances[msg.sender];
+    }
+
+    /// @notice Preleva ether dalla banca
+    /// @dev Non restituisce gli ether inviati in eccesso
+    /// @param withdrawAmount L'importo che si vuole ritirare
+    /// @return remainingBal
+    function withdraw(uint withdrawAmount) public returns (uint remainingBal) {
+        require(withdrawAmount <= balances[msg.sender]);
+
+        // Notiamo come per prima cosa scaliamo i soldi dal saldo, prima di
+        // invarli. Ogni .transfer/.send in questo contratto può chiamare una 
+        // funzione esterna. Questa cosa potrebbe permettere a chi invoca la
+        // funzione di richiedere un importo maggiore del suo saldo usando
+        // una chiamata ricorsiva. Miriamo ad aggiornare lo stato prima che sia
+        // chiamata una funzione esterna, incluse .transfer/.send
+        balances[msg.sender] -= withdrawAmount;
+
+        // Qui lancia automaticamente un errore se fallisce, il che implica
+        // che il saldo (non più aggiornato) viene ripristinato a prima della
+        // transazione
+        msg.sender.transfer(withdrawAmount);
+
+        return balances[msg.sender];
+    }
+
+    /// @notice Recupera il saldo
+    /// @return Il saldo dell'utente
+    // 'view' (ex: constant) impedisce alle funzioni di modificare lo stato
+    // delle variabili; consente alle le funzioni di essere disponibili in
+    // locale/fuori dalla blockchain
+    function balance() view public returns (uint) {
+        return balances[msg.sender];
+    }
+}
+// ** FINE DELL'ESEMPIO **
+
+
+// Passiamo alle basi di Solidity
+
+// 1. TIPI DI DATO E I LORO METODI
+// uint viene usato per gli importi in valuta (non ci sono double o float)
+// e per le date (in unix time)
+uint x;
+
+// int di 256 bit, non possono essere modificati dopo l'istanziazione
+int constant a = 8;
+int256 constant a = 8; // stesso effetto della riga prima, qui viene
+// dichiarato esplicitamente che è di 256 bit
+uint constant VERSION_ID = 0x123A1; // Una costante esadecimale
+// con 'constant', il compilatore rimpiazza ogni occorrenza con il valore
+
+// Tutte le variabili di stato (quelle fuori da una funzione)
+// sono 'interne' di default e accessibili SOLO dall'interno del contratto 
+// e da tutti contratti che le ereditano
+// Bisogna usare esplicitamente 'public' per consentire l'accesso dai contratti 
+// esterni
+int256 public a = 8;
+
+// Per int e uint possiamo esplicitamente assegnare una dimensione tra 8 e 256
+// es. int8, int16, int24
+uint8 b;
+int64 c;
+uint248 e;
+
+// Attenzione a non andare in overflow e a proteggersi dagli attacchi che lo fanno
+// Ad esempio per quanto rigrada l'addizione, conviene fare:
+uint256 c = a + b;
+assert(c >= a); // 'assert' testa gli invarianti interni; require viene usato 
+// per gli input
+// Per altri esempi di problemi comuni con le operazioni aritmentiche, dai una
+// occhiata alla Zeppelin's SafeMath library
+// https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/contracts/math/SafeMath.sol
+
+
+// Non ci sono funzioni random built-in, puoi ottenere un numero pseudo-casuale
+// hashando l'ultimo blockhash, o ottenere un numero realmente casuale usando
+// qualcosa come Chainlink VRF. 
+// https://docs.chain.link/docs/get-a-random-number
+
+// Conversione di tipo
+int x = int(b);
+
+bool b = true; // oppure 'var b = true;' per l'inferenza di tipo
+
+// Indirizzi - contengono indirizzi Ethereum di 20 byte/160 bit
+// Non sono consentite operazioni aritmetiche
+address public owner;
+
+// Tipi di account:
+// Contract account: l'indirizzo viene impostato quando lo si crea (funzione con
+// l'indirzzo di chi lo crea, il numero della transazione inviata)
+// External Account: (persona/enitità esterna): l'indirizzo viene creato dalla
+// chiave pubblica
+
+// Aggiungi il campo 'public' per indicare che è pubblico/accessibile dall'esterno
+// un getter viene creato automaticamente, ma NON un setter
+
+// Si possono mandare ether a tutti gli indirizzi
+owner.transfer(SOME_BALANCE); // fallisce e, in tal caso, ripristina
+// lo stato precedente
+
+// Possiamo anche usare la funzione di livello più basso .send, che restituisce
+// false se fallisce
+if (owner.send) {} // RICORDA: metti la send in un 'if' dato che gli indirizzi
+// usati nei contratti hanno delle funzioni, che vengono eseguite quando viene
+// fatta una send, che possono fallire.
+// Inoltre fai attenzione a scalare i saldi PRIMA di provare a fare una send,
+// dato il rischio di chiamate riscorsive che potrebbero prosciugare il contratto
+
+// Possiamo controllare il saldo
+owner.balance; // il saldo del propietario (utente o contratto)
+
+
+// I Byte sono disposibili in dimensioni da 1 a 32
+byte a; // 'byte' è la stessa cosa di 'bytes1'
+bytes2 b;
+bytes32 c;
+
+// Byte con dimensione dinamica
+bytes m; // Un array particolare, la stessa cosa dell'array 'byte[]' (ma scritto stringato)
+// È più dispendioso di byte1-byte32, che di solito sono preferibili
+
+// come bytes, ma non permette di accedere alla lunghezza o all'indice (per ora)
+string n = "hello"; // salvato in UTF8, nota i doppi apici, non singoli
+// le utility function per le stringhe saranno aggiunte in futuro
+// sono preferibili bytes32/bytes, dato che UTF8 occupa più memoria
+
+// Inferenza di tipo
+// 'var' fa inferenza di tipo a seconda del primo assegnamento,
+// non può essere usata tra i parametri di una funzione
+var a = true;
+// da usare con cautela, può inferire un tipo errato
+// es. un int8 quando un contatore dev'essere un int16
+
+// var può essere usata per assegnare una funzione ad una variabile
+function a(uint x) returns (uint) {
+    return x * 2;
+}
+var f = a;
+f(22); // chiamata
+
+// di default, tutte le variabili sono impostate a 0 durante l'istanziazione
+
+
+// Delete può essere chiamato sulla maggior parte dei valori
+// (NON distrugge il valore, ma lo setta a 0, il valore did default)
+uint x = 5;
+
+
+// Destructuring/Tuple
+(x, y) = (2, 7); // assegna/scambia più valori
+
+
+// 2. STRUTTURE DATI
+// Array
+bytes32[5] nicknames; // array statico
+bytes32[] names; // array dinamico
+uint newLength = names.push("John"); // aggiungere un elemento restituisce
+// la nuova dimensione dell'array
+// Dimesione
+names.length; // ottenere la dimensione
+names.length = 1; // la dimensione può essere assegnata (solo per gli array nello storage)
+
+// array multidimensionali
+uint[][5] x; // array con 5 array dinamici (ordine opposto rispetto ad
+// altri linguaggi)
+
+// Dizionari (da un tipo qualsiasi a un tipo qualsiasi)
+mapping (string => uint) public balances;
+balances["charles"] = 1;
+// il risultato balances["ada"] è 0, tutte le chiavi non settate 
+// restituiscono zero
+// 'public' permette che si possa fare questo da un altro contratto:
+contractName.balances("charles"); // restituisce 1
+// 'public' ha creato getter (ma non un setter), come il seguente:
+function balances(string _account) returns (uint balance) {
+    return balances[_account];
+}
+
+//  Mapping annidati
+mapping (address => mapping (address => uint)) public custodians;
+
+// Fare una delete
+delete balances["John"];
+delete balances; // assegna 0 a tutti gli elementi
+
+// Diversamente da altri linguaggi NON si può iterare tra gli elementi di un
+// mapping senza conoscere le chiavi - ma si può costruire una struttura dati a monte
+// che lo faccia
+
+// Strutture dati
+struct Bank {
+    address owner;
+    uint balance;
+}
+Bank b = Bank({
+    owner: msg.sender,
+    balance: 5
+});
+// oppure
+Bank c = Bank(msg.sender, 5);
+
+c.balance = 5; // imposta ad un nuovo valore
+delete b;
+// reimposta, imposta tutte le variabili della struttura a 0, tranne i mapping
+
+// Enumerazioni
+enum State { Created, Locked, Inactive }; // di solito si usano per gli automi a stati finiti
+State public state; // Dichiara una variabile da un enum
+state = State.Created;
+// Le enum possono essere convertite esplicitamente in int
+uint createdState = uint(State.Created); //  0
+
+// Data location: Memory vs. storage vs. calldata - tutti i tipi complessi
+// (array, struct) hanno una data location
+// 'memory' non è persistente, 'storage' sì
+// Il default è 'storage' per varibili locali e di stato; 
+// 'memory' per i parametri delle funzioni
+// Lo stack può contenere poche varaibili locali
+
+// Per la maggior parte dei tipi, si può impostare esplicitamente
+// quale data location usare
+
+
+// 3. Operatori semplici
+// Ci sono operatori logici, a bit e aritmetici
+// Potenza: **
+// Or esclusivo: ^
+// Negazione bitwise: ~
+
+
+// 4. Variabili globali degne di nota
+// ** this **
+this; // indirizzo del contratto
+// di solito si usa per trasferire altrove il saldo rimanente 
+// al termine della vita del contratto 
+this.balance;
+this.someFunction(); // invoca una funzione esterna tramite chiamata,
+// non attraverso un salto interno
+
+// ** msg - Il messaggio corrente ricevuto dal contratto **
+msg.sender; // indirizzo di chi ha inviato msg
+msg.value; // l'importo di ether forniti a questo contratto espresso in "wei",
+// la funzione dovrebbe essere marcata come "payable"
+msg.data; // in bytes, tutti gli argomenti del messaggio
+msg.gas; // 'gas' restante
+
+// ** tx - Questa transazione **
+tx.origin; // l'indirizzo di chi ha avviato questa transazione
+tx.gasprice; // il prezzo del "gas" per la transazione
+
+// ** block - Informazioni sul blocco attuale **
+now; // ora corrente (approssimatamente), alias di block.timestamp (in Unix time)
+// Da notare come può essere manipolata dai miner, quindi da usare con cautela
+
+block.number; // numero del blocco attuale
+block.difficulty; // difficulty del blocco attuale
+block.blockhash(1); // restituisce un bytes32, funziona solo per i 256 blocchi
+// più recenti
+block.gasLimit();
+
+// ** storage - Memoria persistente (in hash) **
+storage['abc'] = 'def'; // mappa da parole di 256 bit a parole di 256 bit
+
+
+// 4. FUNZIONI E ALTRO
+// A. Funzioni
+// Una semplice funzione
+function increment(uint x) returns (uint) {
+    x += 1;
+    return x;
+}
+
+// Le funzioni possono restituire molti valori,
+// e visto che i valori di ritorno vengono dichiarati prima
+// non è richiesta un'instruzione return esplicita
+function increment(uint x, uint y) returns (uint x, uint y) {
+    x += 1;
+    y += 1;
+}
+// Chiama la funzione di cui sopra
+uint (a,b) = increment(1,1);
+
+// 'view' (un alias di 'constant')
+// indica che la funzione non cambia / non può cambiare le variabili persistenti
+// Le funzioni definite con view vengono eseguite localmente, non sulla blockchain
+// N.B. la keyword constant sarà presto deprecata
+uint y = 1;
+
+function increment(uint x) view returns (uint x) {
+    x += 1;
+    y += 1; // questa riga fallirebbe
+    // y è una variabile di stato, e non può essere cambiata in una funzione di view
+}
+
+// 'pure' è più restrittivo di 'view' o 'constant', e non
+// permette nemmeno di leggere le varaibili di stato
+// In realtà è più complicato, per approfondire su
+// view/pure:
+// http://solidity.readthedocs.io/en/develop/contracts.html#view-functions
+
+// Modificatori di visibilità per le funzioni
+// Possono essere messi vicino a 'view' e includono:
+// public - visibile esternamente e internamente (di default per function)
+// external - visible solo esternamente (comprese le chiamate fatte con this.)
+// private - visibile solo dal contratto attuale
+// internal - visibile solo dal contratto attuale, e da quelli che ne derivano
+
+// Di solito è una buona idea marcare esplicitamente ogni funzione
+
+// Le funzioni sono hoisted e si può assegnare una funzione ad una variabile
+function a() {
+    var z = b;
+    b();
+}
+
+function b() {
+
+}
+
+// Tutte le funzioni che ricevono ether devono essere dichiarate come 'payable'
+function depositEther() public payable {
+    balances[msg.sender] += msg.value;
+}
+
+
+// I cicli sono da preferire alla ricorsione
+// (la profondità massima dello stack è 1024)
+// Inoltre, non impostare dei loop senza limiti,
+// perchè potresti raggiungere il limite per il gas
+
+// B. Eventi
+// Gli eventi notificano a terze parti; è facile ispezionare e
+// accedere agli eventi al di fuori della blockchain (con client leggeri);
+// Tipicamente si dichiarano dopo i parametri del contratto
+
+// Tipicamente, sono capitalized - si usa Log come prefisso per esplicitarli
+// meglio ed evitare che si confondano con una chiamata a funzione
+
+// Dichiarazione
+event LogSent(address indexed from, address indexed to, uint amount); 
+// Da notare le prime lettere maiuscole
+
+// Chiamata
+LogSent(from, to, amount);
+
+/**
+
+Una terza parte esterna (entità o contratto), può osservare usando
+la libreria Javascript Web3:
+
+// Quel che se segue è codice Javascript, non Solidity
+Coin.LogSent().watch({}, '', function(error, result) {
+    if (!error) {
+        console.log("Trasferimento valuta: " + result.args.amount +
+            " la valuta è stata mandata da " + result.args.from +
+            " a " + result.args.to + ".");
+        console.log("I saldi ora sono:\n" +
+            "Mittente: " + Coin.balances.call(result.args.from) +
+            "Destinatario: " + Coin.balances.call(result.args.to));
+    }
+}
+**/
+
+// È prassi che un contratto dipenda da un altro (es. che dipenda
+// dai tassi di cambio forniti da un altro contratto)
+
+// C. Modifier
+// I modifier validano gli input per conto dele funzioni verificando ad esempio
+// il saldo minimo o l'autenticazione dell'utente;
+// sono simili alle calusole di guardia di altri linguaggi
+
+// '_' (underscore) viene spesso posizionato nell'ultima riga del body, e indica
+// che la funzione chiamata dev'essere posizionata lì
+modifier onlyAfter(uint _time) { require (now >= _time); _; }
+modifier onlyOwner { require(msg.sender == owner) _; }
+// usate comunemente negli automi a stati finiti
+modifier onlyIfStateA (State currState) { require(currState == State.A) _; }
+
+// Si dichiarano appena dopo la definizione di una funzione
+function changeOwner(newOwner)
+onlyAfter(someTime)
+onlyOwner()
+onlyIfState(State.A)
+{
+    owner = newOwner;
+}
+
+// L'underscore può essere messo prima della fine del body,
+// ma un'istruzione di ritorno esplicita lo salterebbe,
+// quindi è da usare con cautela
+modifier checkValue(uint amount) {
+    _;
+    if (msg.value > amount) {
+        uint amountToRefund = amount - msg.value;
+        msg.sender.transfer(amountToRefund);
+    }
+}
+
+
+// 6. ISTRUZIONI CONDIZIONALI E CICLI
+
+// Troviamo tutte le istruzioni condizionali di base - incluse if/else, for,
+// while, break, continue e return - ma non c'è lo switch
+
+// La sintassi è la stessa di javascript, ma non esiste la conversione di tipo
+// in booleano dai non booleani (bisogna usare gli operatori logici per
+// ottenere il valore boolean)
+
+// Bisogna stare attenti i loop che iterano in base al comportamento
+// dell'utente, dato che i contratti hanno un tetto massimo di gas
+// per blocco di codice e falliranno se lo superano
+// Ad esempio:
+for(uint x = 0; x < refundAddressList.length; x++) {
+    refundAddressList[x].transfer(SOME_AMOUNT);
+}
+
+// Ci sono due errori nel codice precedente:
+// 1. Un fallimento su una transfer impedisce al loop di completare tutti
+// i cicli, bloccando dei soldi;
+// 2. Questo loop potrebbe essere arbitrariamente lungo (si basa sul numero
+// degli utenti che hanno diritto al rimborso), quindi potrebbe fallire sempre
+// se supera il tetto massimo di gas per blocco;
+// Come soluzione, si permette agli utenti di prelevare
+// individualmente dal loro subaccount e segnare il rimborso come riscosso
+// Ad es. preferire pull payments ai push payment
+
+
+// 7. OGGETTI/CONTRATTI
+
+// A. Invocare un contratto esterno
+contract InfoFeed {
+    function info() payable returns (uint ret)  { return 42; }
+}
+
+contract Consumer {
+    InfoFeed feed; // punta ad un contratto sulla blockchain
+
+    // Imposta il feed sull'istanza del contratto esistente
+    function setFeed(address addr) {
+        // fare attenzione alla conversione di tipo automatica;
+        // il costruttore non viene invocato
+        feed = InfoFeed(addr);
+    }
+
+    // Imposta il feed ad una nuova istanza del contratto
+    function createNewFeed() {
+        feed = new InfoFeed(); // viene creata una nuova istanza;
+        // viene invocato il costruttore
+    }
+
+    function callFeed() {
+        // le parentesi finali invocano il contratto, opzionalmente si può
+        // specificare un importo custom di ether o di gas
+        feed.info.value(10).gas(800)();
+    }
+}
+
+// B. ereditarietà
+
+// Conta l'ordine, l'ultimo contratto ereditato (es. 'def') può andare
+// in overriding su parti dei contratti precedentemente ereditati
+contract MyContract is abc, def("a custom argument to def") {
+
+// Funzione in overriding
+    function z() {
+        if (msg.sender == owner) {
+            def.z(); // invoca la funzione overridden da def
+            super.z(); // chiama la funzione overridden del padre
+        }
+    }
+}
+
+// Funzioni astratte
+function someAbstractFunction(uint x);
+// non possono essere compilate, vengono usate nei contratti base/astratti
+// e poi verranno implementate
+
+// C. Import
+
+import "filename";
+import "github.com/ethereum/dapp-bin/library/iterable_mapping.sol";
+
+
+// 8. ALTRE KEYWORD
+
+// A. Selfdestruct
+// autodistrugge il contratto corrente, inviando i fondi ad un indirizzo
+// (di solito il creatore)
+selfdestruct(SOME_ADDRESS);
+
+// rimuove il codice e quanto in memoria dal blocco corrente e da tutti i blocchi futuri
+// aiuta ad alleggerire i client, ma le informazioni precedenti continueranno
+// a persistere sulla blockchain
+
+// È un pattern comune, permette al proprietario di terminare il contratto
+// e ricevere i fondi rimasti
+function remove() {
+    if(msg.sender == creator) { // Solo il creatore del contratto può farlo
+        selfdestruct(creator); // Cessa l'attività del contratto, trasferisce i fondi
+    }
+}
+
+// Si potrebbe voler disattivare il contratto manualmente, anzichè usare una
+// selfdestruct (gli ether inviati ad un contratto dopo una selfdestruct
+// vengono persi)
+
+
+// 9. NOTE SUL DESIGN DEI CONTRATTI
+
+// A. Offruscamento
+// Tutte le variabili sono pubblicamente visibili sulla blockchain, quindi 
+// qualsiasi informazione privata ha bisogno di essere offruscata (es. hash con una
+// chiave segreta)
+
+// Passi: 1. Impegnarsi pagare una certa cifra, 2. Rivelare l'impegno preso
+keccak256("una_puntata_d_asta", "un segreto"); // impegno
+
+// in futuro, l'invocazione della funzione rivelatrice del contratto
+// mostrerà la puntata con il segreto che produce lo SHA3
+reveal(100, "ilMioSegreto");
+
+// B. Ottimizzazione della memoria (storage)
+// Scrivere dati sulla blockchain può essere costoso visto che vengono 
+// conservati per sempre; siamo incoraggati ad usare la memoria in maniera
+// scaltra (un giorno la compilazione migliorerà, ma per ora è vantaggioso
+// pianificare le strutture dati da usare - e conservarne il minimo possibile
+// sulla blockchain)
+
+// I costi per conservare cose come array multidimensionali sono spesso alti
+// (costa conservare dati - non dichiarare variabili parzialmente vuote)
+
+// C. Accesso ai dati sulla blockchain
+// Non si può impedire alle persone o ai computer di leggere il contenuto
+// o lo stato delle transazioni
+
+// Anche se 'private' non permette agli altri *contratti* di leggere alcune
+// informazioni direttamente, qualsiasi altro attore può leggerle
+// sulla blockchain
+
+// Tutti i dati, dall'inizio, vegono conservati sulla blockchain e
+// tutti possono accedere alle informazioni passate e ai cambiamenti futuri
+
+// D. Oracle e dati esterni
+// Gli oracle consentono di interagire con i tuoi smart contract
+// al di fuori della blockchain. 
+// Vengono usati per ricevere informazioni dal mondo reale, mandare
+// richieste post al mondo reale o vice versa.
+
+// Anche le implementazioni che sfruttano l'ora vengono fatte attraverso
+// gli oracle, visto che i contratti devono essere chiamati direttamente e
+// non possono fare una "subscribe" a un certo orario. 
+// Data la decentralizzazione degli smart contract, vorrai ricevere informazioni
+// in maniera decentralizzata, altrimenti rischi di ricreare l'accentramento
+// che la progettazione degli smart contract si prefigge di prevenire.
+
+// Il modo migliore di ottenere e usare dati decentralizzati già pronti
+// è attraverso i Chainlink Data Feeds
+// https://docs.chain.link/docs/get-the-latest-price
+// Possiamo fare riferimento a certe informazioni della blockchain
+// che sono già state aggregate da più fonti e ridistribuite on-chain,
+// usandole come "banche dati" di fonti di informazione. 
+
+// Puoi vedere altri esempi che effettuano chiamate alle API qui:
+// https://docs.chain.link/docs/make-a-http-get-request
+
+// E ovviamente puoi costruire la tua rete di orace, ma assicurati di sapere
+// quant'è accentrata o decentralizzata la tua applicazione. 
+
+// Mettere su una rete di oracle per conto tuo
+
+// E. Cron Job
+// I contratti devono essere chiamati manualmente per gestire lo scheduling
+// in base all'orario; si può creare un codice esterno che li pinghi reglarmente
+//  oppure fornire degli incentivi (ether) a qualcun'altro che lo faccia
+
+// F. Pattern Observer
+// Un pattern observer permette di iscriversi come osservatore e
+// registrare una funzione che verrà chiamata dall'oracle
+// (N.B. l'oracolo paga perchè sia eseguita quest'azione)
+// Ci sono alcune somoglianze nella registrazione con Pub/sub
+
+// Questo è un contratto astratto che importano sia il client che il server
+// Il client dovrebbe implementarlo
+contract SomeOracleCallback {
+    function oracleCallback(int _value, uint _time, bytes32 info) external;
+}
+
+contract SomeOracle {
+    SomeOracleCallback[] callbacks; // array di tutti gli osservatori iscritti
+
+    // Osservatori iscritti
+    function addSubscriber(SomeOracleCallback a) {
+        callbacks.push(a);
+    }
+
+    function notify(value, time, info) private {
+        for(uint i = 0;i < callbacks.length; i++) {
+            // tutti gli osservatori iscritti dovranno implementare la oracleCallback
+            callbacks[i].oracleCallback(value, time, info);
+        }
+    }
+
+    function doSomething() public {
+        // Codice che fa qualcosa
+
+        // Notifica a tutti gli iscritti
+        notify(_value, _time, _info);
+    }
+}
+
+// Il contratto client può aggiungersi agli iscritti (con addSubscriber) 
+// del contratto SomeOracle, importando SomeOracleCallback
+
+// G. Automi a stati finiti
+// vedi l'esempio sotto che usa enum per lo stato e il modifier inState
+```
+
+Prova l'esempio completo qui sotto [usando remix e la `Javascript VM`](https://remix.ethereum.org/#version=soljson-v0.6.6+commit.6c089d02.js&optimize=false&evmVersion=null&gist=3d12cd503dcedfcdd715ef61f786be0b&runs=200)
+
+```javascript
+// *** ESEMPIO: Un esempio di crowdfunding (molto simile a Kickstarter) ***
+// ** START EXAMPLE **
+
+// CrowdFunder.sol
+pragma solidity ^0.6.6;
+
+/// @title CrowdFunder
+/// @author nemild
+contract CrowdFunder {
+    // Variabili impostate alla creazione dal creatore
+    address public creator;
+    address payable public fundRecipient; // il creatore può essere diverso
+    // da chi riceve i fondi, che dev'essere payable
+    uint public minimumToRaise; // è richiesto per chiedere il finanziamento,
+    // altrimenti tutti ricevono un rimborso
+    string campaignUrl;
+    byte version = "1";
+
+    // Strutture dati
+    enum State {
+        Fundraising,
+        ExpiredRefund,
+        Successful
+    }
+    struct Contribution {
+        uint amount;
+        address payable contributor;
+    }
+
+    // Variabili di stato
+    State public state = State.Fundraising; // inizializzato alla creazione
+    uint public totalRaised;
+    uint public raiseBy;
+    uint public completeAt;
+    Contribution[] contributions;
+
+    event LogFundingReceived(address addr, uint amount, uint currentTotal);
+    event LogWinnerPaid(address winnerAddress);
+
+    modifier inState(State _state) {
+        require(state == _state);
+        _;
+    }
+
+    modifier isCreator() {
+        require(msg.sender == creator);
+        _;
+    }
+
+    // Aspetta 24 settimane dopo l'ultimo cambio di stato prima di consentire
+    // che in contratto venga distrutto
+    modifier atEndOfLifecycle() {
+    require(((state == State.ExpiredRefund || state == State.Successful) &&
+        completeAt + 24 weeks < now));
+        _;
+    }
+
+    function crowdFund(
+        uint timeInHoursForFundraising,
+        string memory _campaignUrl,
+        address payable _fundRecipient,
+        uint _minimumToRaise)
+        public
+    {
+        creator = msg.sender;
+        fundRecipient = _fundRecipient;
+        campaignUrl = _campaignUrl;
+        minimumToRaise = _minimumToRaise;
+        raiseBy = now + (timeInHoursForFundraising * 1 hours);
+    }
+
+    function contribute()
+    public
+    payable
+    inState(State.Fundraising)
+    returns(uint256 id)
+    {
+        contributions.push(
+            Contribution({
+                amount: msg.value,
+                contributor: msg.sender
+            }) // usiamo un array per iterare
+        );
+        totalRaised += msg.value;
+
+        emit LogFundingReceived(msg.sender, msg.value, totalRaised);
+
+        checkIfFundingCompleteOrExpired();
+        return contributions.length - 1; // restituisce l'id
+    }
+
+    function checkIfFundingCompleteOrExpired()
+    public
+    {
+        if (totalRaised > minimumToRaise) {
+            state = State.Successful;
+            payOut();
+
+            // qui si può incentivare chi ha provocato il cambiamento di stato
+        } else if ( now > raiseBy )  {
+            state = State.ExpiredRefund; // ora i finanziatori possono avere
+            // il rimborso chiamando getRefund(id)
+        }
+        completeAt = now;
+    }
+
+    function payOut()
+    public
+    inState(State.Successful)
+    {
+        fundRecipient.transfer(address(this).balance);
+        LogWinnerPaid(fundRecipient);
+    }
+
+    function getRefund(uint256 id)
+    inState(State.ExpiredRefund)
+    public
+    returns(bool)
+    {
+        require(contributions.length > id && id >= 0 && contributions[id].amount != 0 );
+
+        uint256 amountToRefund = contributions[id].amount;
+        contributions[id].amount = 0;
+
+        contributions[id].contributor.transfer(amountToRefund);
+
+        return true;
+    }
+
+    function removeContract()
+    public
+    isCreator()
+    atEndOfLifecycle()
+    {
+        selfdestruct(msg.sender);
+        // il creatore riceve tutti i fondi che non sono stati riscossi
+    }
+}
+// ** END EXAMPLE **
+
+```
+
+Qualche altra funzionalità.
+
+```javascript
+// 10. ATRE FUNZIONALITA' NATIVE
+
+// Unità di valuta
+// La valuta viene definita partendo dai wei, l'unità più piccola di Ether
+uint minAmount = 1 wei;
+uint a = 1 finney; // 1 ether == 1000 finney
+// Per altre unità, vedi: http://ether.fund/tool/converter
+
+// Unità temporali
+1 == 1 second
+1 minutes == 60 seconds
+
+// Le unità temporali si possono moltiplicare, visto che non vegono salvate
+// nelle variabili
+uint x = 5;
+(x * 1 days); // 5 giorni
+
+// Attenzione ad usare l'operatore di uguaglianza con i secondi/anni bisestili
+// (sono da preferire maggiore/minore di)
+
+// Crittografia
+// Tutte le stringhe che vengono passate vengono concatenate prima di
+// calcolare l'hash
+sha3("ab", "cd");
+ripemd160("abc");
+sha256("def");
+
+
+// 11.SICUREZZA
+
+// I bug possono essere disastrosi per i contratti Ethereum e anche 
+// i pattern comuni di Solidity potrebbero riverlarsi degli antipattern
+
+// Dai un'occhiata ai link sulla sicurezza alla fine di questo documento
+
+
+// 12. FUNZIONI DI BASSO LIVELLO
+// call - è di basso livello, non viene usata spesso, perchè non è type safe
+successBoolean = someContractAddress.call('function_name', 'arg1', 'arg2');
+
+// callcode - Il codice all'indirizzo target viene eseguito *contestualmente*
+// alla chiamata del contratto
+// fornisce le stesse funzionalità di una libreria
+someContractAddress.callcode('function_name');
+
+
+// 13. NOTE SULLO STILE
+// Basate sulla guida allo stile PEP8 di Python
+// Guida completa allo stile: http://solidity.readthedocs.io/en/develop/style-guide.html
+
+// Riassunto veloce:
+// 4 spazi per l'indentazione
+// Due righe per separare la dichiarazione dei contratti
+// (e altre dichirazioni top level)
+// Evitare spazi ai lati interni delle parentesi tonde
+// Si possono omettere le parentesi graffe per statement monolinea (if, for, etc)
+// L'else dovrebbe essere posizionato su una riga a se
+
+// 14. COMMENTI NATSPEC
+// usati per la documentazione, commenti e UI esterne
+
+// Natspec dei contratti - sempre sopra la definizione del contratto
+/// @title Titolo del contratto
+/// @author Nome dell'autore
+
+// Natspec delle funzioni
+/// @notice informazioni su quel che fa la funzione; mostrate quando la funzione viene eseguita
+/// @dev Documentazione della funzione per sviluppatori
+
+// Natspec dei parametri/valori di ritorno delle funzioni
+/// @param someParam Una descrizione di quel che fa il parametro
+/// @return Descrizione del valore di ritorno
+```
+
+## Risorse Aggiuntive
+- [Documentazione di Solidity](https://solidity.readthedocs.org/en/latest/)
+- [Tutorial Chainlink per Principianti](https://docs.chain.link/docs/beginners-tutorial)
+- [Best Practice  per Smart Contract](https://github.com/ConsenSys/smart-contract-best-practices)
+- [Superblocks Lab - Ambiente di sviluppo su browser per Solidity](https://lab.superblocks.com/)
+- [EthFiddle - Il JsFiddle di Solidity](https://ethfiddle.com/)
+- [Solidity Editor su Browser](https://remix.ethereum.org/)
+- [Chat Room Gitter su Solidity](https://gitter.im/ethereum/solidity)
+- [Stategie di Progettazione Modulare per Contratti Ethereum](https://docs.erisindustries.com/tutorials/solidity/)
+- [Documentazione Chainlink](https://docs.chain.link/docs/getting-started)
+
+## Framework di Sviluppo per Smart Contract
+- [Hardhat](https://hardhat.org/)
+- [Brownie](https://github.com/eth-brownie/brownie)
+- [Truffle](https://www.trufflesuite.com/)
+
+## Librerie importanti
+- [Zeppelin](https://github.com/OpenZeppelin/openzeppelin-contracts): Librerie che offrono pattern comuni (crowdfuding, safemath, ecc)
+- [Chainlink](https://github.com/smartcontractkit/chainlink): Codice che permette di interagire con dati esterni
+
+## Contratti di esempio
+- [Dapp Bin](https://github.com/ethereum/dapp-bin)
+- [Esempi Defi](https://github.com/PatrickAlphaC/chainlink_defi)
+- [Solidity per Contratti a Piccoli Passi](https://github.com/fivedogit/solidity-baby-steps/tree/master/contracts)
+- [Contratti ConsenSys](https://github.com/ConsenSys/dapp-store-contracts)
+- [Lo stato delle Dapp](http://dapps.ethercasts.com/)
+
+## Sicurezza
+- [Pensando Alla Sicurezza Degli Smart Contract](https://blog.ethereum.org/2016/06/19/thinking-smart-contract-security/)
+- [Sicurezza Degli Smart Contract](https://blog.ethereum.org/2016/06/10/smart-contract-security/)
+- [Blog Distribuito di Hacking](http://hackingdistributed.com/)
+
+## Stile
+- [Guida allo Stile di Solidity](http://solidity.readthedocs.io/en/latest/style-guide.html): La guida allo stile di Ethereum deriva in gran parte dalla guida allo stile [PEP 8](https://www.python.org/dev/peps/pep-0008/) di Python.
+
+## Editor
+- [Remix](https://remix.ethereum.org/)
+- [Emacs Modalità Solidity](https://github.com/ethereum/emacs-solidity)
+- [Vim Solidity](https://github.com/tomlion/vim-solidity)
+- Snippet per gli Editor ([Ultisnips format](https://gist.github.com/nemild/98343ce6b16b747788bc))
+
+## Cose da fare in futuro
+- Nuove keyword: protected, inheritable
+- Lista dei design pattern comuni (throttling, RNG, upgrade di versione)
+-Anti patterns comuni sulla sicurezza
+
+Sentiti libero di mandare una pull request con qualsiasi modifica - o scrivi una mail a nemild -/at-/ gmail
diff --git a/it-it/toml-it.html.markdown b/it-it/toml-it.html.markdown
index 99082048..beb63096 100644
--- a/it-it/toml-it.html.markdown
+++ b/it-it/toml-it.html.markdown
@@ -1,276 +1,276 @@
----

-language: toml

-filename: learntoml-it.toml

-contributors:

-  - ["Alois de Gouvello", "https://github.com/aloisdg"]

-translators:

-  - ["Christian Grasso", "https://grasso.io"]

-lang: it-it

----

-

-TOML è l'acronimo di _Tom's Obvious, Minimal Language_. È un linguaggio per la

-serializzazione di dati, progettato per i file di configurazione.

-

-È un'alternativa a linguaggi come YAML e JSON, che punta ad essere più leggibile

-per le persone. Allo stesso tempo, TOML può essere utilizzato in modo abbastanza

-semplice nella maggior parte dei linguaggi di programmazione, in quanto è

-progettato per essere tradotto senza ambiguità in una hash table.

-

-Tieni presente che TOML è ancora in fase di sviluppo, e la sua specifica non è

-ancora stabile. Questo documento utilizza TOML 0.4.0.

-

-```toml

-# I commenti in TOML sono fatti così.

-

-################

-# TIPI SCALARI #

-################

-

-# Il nostro oggetto root (corrispondente all'intero documento) sarà una mappa,

-# anche chiamata dizionario, hash o oggetto in altri linguaggi.

-

-# La key, il simbolo di uguale e il valore devono trovarsi sulla stessa riga,

-# eccetto per alcuni tipi di valori.

-key = "value"

-stringa = "ciao"

-numero = 42

-float = 3.14

-boolean = true

-data = 1979-05-27T07:32:00-08:00

-notazScientifica = 1e+12

-"puoi utilizzare le virgolette per la key" = true # Puoi usare " oppure '

-"la key può contenere" = "lettere, numeri, underscore e trattini"

-

-############

-# Stringhe #

-############

-

-# Le stringhe possono contenere solo caratteri UTF-8 validi.

-# Possiamo effettuare l'escape dei caratteri, e alcuni hanno delle sequenze

-# di escape compatte. Ad esempio, \t corrisponde al TAB.

-stringaSemplice = "Racchiusa tra virgolette. \"Usa il backslash per l'escape\"."

-

-stringaMultiriga = """

-Racchiusa da tre virgolette doppie all'inizio e

-alla fine - consente di andare a capo."""

-

-stringaLiteral = 'Virgolette singole. Non consente di effettuare escape.'

-

-stringaMultirigaLiteral = '''

-Racchiusa da tre virgolette singole all'inizio e

-alla fine - consente di andare a capo.

-Anche in questo caso non si può fare escape.

-Il primo ritorno a capo viene eliminato.

-   Tutti gli altri spazi aggiuntivi

-   vengono mantenuti.

-'''

-

-# Per i dati binari è consigliabile utilizzare Base64 e

-# gestirli manualmente dall'applicazione.

-

-##########

-# Interi #

-##########

-

-## Gli interi possono avere o meno un segno (+, -).

-## Non si possono inserire zero superflui all'inizio.

-## Non è possibile inoltre utilizzare valori numerici

-## non rappresentabili con una sequenza di cifre.

-int1 = +42

-int2 = 0

-int3 = -21

-

-## Puoi utilizzare gli underscore per migliorare la leggibilità.

-## Fai attenzione a non inserirne due di seguito.

-int4 = 5_349_221

-int5 = 1_2_3_4_5     # VALIDO, ma da evitare

-

-#########

-# Float #

-#########

-

-# I float permettono di rappresentare numeri decimali.

-flt1 = 3.1415

-flt2 = -5e6

-flt3 = 6.626E-34

-

-###########

-# Boolean #

-###########

-

-# I valori boolean (true/false) devono essere scritti in minuscolo.

-bool1 = true

-bool2 = false

-

-############

-# Data/ora #

-############

-

-data1 = 1979-05-27T07:32:00Z # Specifica RFC 3339/ISO 8601 (UTC)

-data2 = 1979-05-26T15:32:00+08:00 # RFC 3339/ISO 8601 con offset

-

-######################

-# TIPI DI COLLECTION #

-######################

-

-#########

-# Array #

-#########

-

-array1 = [ 1, 2, 3 ]

-array2 = [ "Le", "virgole", "sono", "delimitatori" ]

-array3 = [ "Non", "unire", "tipi", "diversi" ]

-array4 = [ "tutte", 'le stringhe', """hanno lo stesso""", '''tipo''' ]

-array5 = [

-  "Gli spazi vuoti", "sono", "ignorati"

-]

-

-###########

-# Tabelle #

-###########

-

-# Le tabelle (o hash table o dizionari) sono collection di coppie key/value.

-# Iniziano con un nome tra parentesi quadre su una linea separata. 

-# Le tabelle vuote (senza alcun valore) sono valide.

-[tabella]

-

-# Tutti i valori che si trovano sotto il nome della tabella

-# appartengono alla tabella stessa (finchè non ne viene creata un'altra).

-# L'ordine di questi valori non è garantito.

-[tabella-1]

-key1 = "una stringa"

-key2 = 123

-

-[tabella-2]

-key1 = "un'altra stringa"

-key2 = 456

-

-# Utilizzando i punti è possibile creare delle sottotabelle.

-# Ogni parte suddivisa dai punti segue le regole delle key per il nome.

-[tabella-3."sotto.tabella"]

-key1 = "prova"

-

-# Ecco l'equivalente JSON della tabella precedente:

-# { "tabella-3": { "sotto.tabella": { "key1": "prova" } } }

-

-# Gli spazi non vengono considerati, ma è consigliabile

-# evitare di usare spazi superflui.

-[a.b.c]            # consigliato

-[ d.e.f ]          # identico a [d.e.f]

-

-# Non c'è bisogno di creare le tabelle superiori per creare una sottotabella.

-# [x] queste

-# [x.y] non

-# [x.y.z] servono

-[x.y.z.w] # per creare questa tabella

-

-# Se non è stata già creata prima, puoi anche creare

-# una tabella superiore più avanti.

-[a.b]

-c = 1

-

-[a]

-d = 2

-

-# Non puoi definire una key o una tabella più di una volta.

-

-# ERRORE

-[a]

-b = 1

-

-[a]

-c = 2

-

-# ERRORE

-[a]

-b = 1

-

-[a.b]

-c = 2

-

-# I nomi delle tabelle non possono essere vuoti.

-[]     # NON VALIDO

-[a.]   # NON VALIDO

-[a..b] # NON VALIDO

-[.b]   # NON VALIDO

-[.]    # NON VALIDO

-

-##################

-# Tabelle inline #

-##################

-

-tabelleInline = { racchiuseData = "{ e }", rigaSingola = true }

-punto = { x = 1, y = 2 }

-

-####################

-# Array di tabelle #

-####################

-

-# Un array di tabelle può essere creato utilizzando due parentesi quadre.

-# Tutte le tabelle con questo nome saranno elementi dell'array.

-# Gli elementi vengono inseriti nell'ordine in cui si trovano.

-

-[[prodotti]]

-nome = "array di tabelle"

-sku = 738594937

-tabelleVuoteValide = true

-

-[[prodotti]]

-

-[[prodotti]]

-nome = "un altro item"

-sku = 284758393

-colore = "grigio"

-

-# Puoi anche creare array di tabelle nested. Le sottotabelle con doppie

-# parentesi quadre apparterranno alla tabella più vicina sopra di esse.

-

-[[frutta]]

-  nome = "mela"

-

-  [frutto.geometria]

-    forma = "sferica"

-    nota = "Sono una proprietà del frutto"

-

-  [[frutto.colore]]

-    nome = "rosso"

-    nota = "Sono un oggetto di un array dentro mela"

-

-  [[frutto.colore]]

-    nome = "verde"

-    nota = "Sono nello stesso array di rosso"

-

-[[frutta]]

-  nome = "banana"

-

-  [[frutto.colore]]

-    nome = "giallo"

-    nota = "Anche io sono un oggetto di un array, ma dentro banana"

-```

-

-Ecco l'equivalente JSON dell'ultima tabella:

-

-```json

-{

-  "frutta": [

-    {

-      "nome": "mela",

-      "geometria": { "forma": "sferica", "nota": "..."},

-      "colore": [

-        { "nome": "rosso", "nota": "..." },

-        { "nome": "verde", "nota": "..." }

-      ]

-    },

-    {

-      "nome": "banana",

-      "colore": [

-        { "nome": "giallo", "nota": "..." }

-      ]

-    }

-  ]

-}

-```

-

-### Altre risorse

-

-+ [Repository ufficiale di TOML](https://github.com/toml-lang/toml)

+---
+language: toml
+filename: learntoml-it.toml
+contributors:
+  - ["Alois de Gouvello", "https://github.com/aloisdg"]
+translators:
+  - ["Christian Grasso", "https://grasso.io"]
+lang: it-it
+---
+
+TOML è l'acronimo di _Tom's Obvious, Minimal Language_. È un linguaggio per la
+serializzazione di dati, progettato per i file di configurazione.
+
+È un'alternativa a linguaggi come YAML e JSON, che punta ad essere più leggibile
+per le persone. Allo stesso tempo, TOML può essere utilizzato in modo abbastanza
+semplice nella maggior parte dei linguaggi di programmazione, in quanto è
+progettato per essere tradotto senza ambiguità in una hash table.
+
+Tieni presente che TOML è ancora in fase di sviluppo, e la sua specifica non è
+ancora stabile. Questo documento utilizza TOML 0.4.0.
+
+```toml
+# I commenti in TOML sono fatti così.
+
+################
+# TIPI SCALARI #
+################
+
+# Il nostro oggetto root (corrispondente all'intero documento) sarà una mappa,
+# anche chiamata dizionario, hash o oggetto in altri linguaggi.
+
+# La key, il simbolo di uguale e il valore devono trovarsi sulla stessa riga,
+# eccetto per alcuni tipi di valori.
+key = "value"
+stringa = "ciao"
+numero = 42
+float = 3.14
+boolean = true
+data = 1979-05-27T07:32:00-08:00
+notazScientifica = 1e+12
+"puoi utilizzare le virgolette per la key" = true # Puoi usare " oppure '
+"la key può contenere" = "lettere, numeri, underscore e trattini"
+
+############
+# Stringhe #
+############
+
+# Le stringhe possono contenere solo caratteri UTF-8 validi.
+# Possiamo effettuare l'escape dei caratteri, e alcuni hanno delle sequenze
+# di escape compatte. Ad esempio, \t corrisponde al TAB.
+stringaSemplice = "Racchiusa tra virgolette. \"Usa il backslash per l'escape\"."
+
+stringaMultiriga = """
+Racchiusa da tre virgolette doppie all'inizio e
+alla fine - consente di andare a capo."""
+
+stringaLiteral = 'Virgolette singole. Non consente di effettuare escape.'
+
+stringaMultirigaLiteral = '''
+Racchiusa da tre virgolette singole all'inizio e
+alla fine - consente di andare a capo.
+Anche in questo caso non si può fare escape.
+Il primo ritorno a capo viene eliminato.
+   Tutti gli altri spazi aggiuntivi
+   vengono mantenuti.
+'''
+
+# Per i dati binari è consigliabile utilizzare Base64 e
+# gestirli manualmente dall'applicazione.
+
+##########
+# Interi #
+##########
+
+## Gli interi possono avere o meno un segno (+, -).
+## Non si possono inserire zero superflui all'inizio.
+## Non è possibile inoltre utilizzare valori numerici
+## non rappresentabili con una sequenza di cifre.
+int1 = +42
+int2 = 0
+int3 = -21
+
+## Puoi utilizzare gli underscore per migliorare la leggibilità.
+## Fai attenzione a non inserirne due di seguito.
+int4 = 5_349_221
+int5 = 1_2_3_4_5     # VALIDO, ma da evitare
+
+#########
+# Float #
+#########
+
+# I float permettono di rappresentare numeri decimali.
+flt1 = 3.1415
+flt2 = -5e6
+flt3 = 6.626E-34
+
+###########
+# Boolean #
+###########
+
+# I valori boolean (true/false) devono essere scritti in minuscolo.
+bool1 = true
+bool2 = false
+
+############
+# Data/ora #
+############
+
+data1 = 1979-05-27T07:32:00Z # Specifica RFC 3339/ISO 8601 (UTC)
+data2 = 1979-05-26T15:32:00+08:00 # RFC 3339/ISO 8601 con offset
+
+######################
+# TIPI DI COLLECTION #
+######################
+
+#########
+# Array #
+#########
+
+array1 = [ 1, 2, 3 ]
+array2 = [ "Le", "virgole", "sono", "delimitatori" ]
+array3 = [ "Non", "unire", "tipi", "diversi" ]
+array4 = [ "tutte", 'le stringhe', """hanno lo stesso""", '''tipo''' ]
+array5 = [
+  "Gli spazi vuoti", "sono", "ignorati"
+]
+
+###########
+# Tabelle #
+###########
+
+# Le tabelle (o hash table o dizionari) sono collection di coppie key/value.
+# Iniziano con un nome tra parentesi quadre su una linea separata. 
+# Le tabelle vuote (senza alcun valore) sono valide.
+[tabella]
+
+# Tutti i valori che si trovano sotto il nome della tabella
+# appartengono alla tabella stessa (finchè non ne viene creata un'altra).
+# L'ordine di questi valori non è garantito.
+[tabella-1]
+key1 = "una stringa"
+key2 = 123
+
+[tabella-2]
+key1 = "un'altra stringa"
+key2 = 456
+
+# Utilizzando i punti è possibile creare delle sottotabelle.
+# Ogni parte suddivisa dai punti segue le regole delle key per il nome.
+[tabella-3."sotto.tabella"]
+key1 = "prova"
+
+# Ecco l'equivalente JSON della tabella precedente:
+# { "tabella-3": { "sotto.tabella": { "key1": "prova" } } }
+
+# Gli spazi non vengono considerati, ma è consigliabile
+# evitare di usare spazi superflui.
+[a.b.c]            # consigliato
+[ d.e.f ]          # identico a [d.e.f]
+
+# Non c'è bisogno di creare le tabelle superiori per creare una sottotabella.
+# [x] queste
+# [x.y] non
+# [x.y.z] servono
+[x.y.z.w] # per creare questa tabella
+
+# Se non è stata già creata prima, puoi anche creare
+# una tabella superiore più avanti.
+[a.b]
+c = 1
+
+[a]
+d = 2
+
+# Non puoi definire una key o una tabella più di una volta.
+
+# ERRORE
+[a]
+b = 1
+
+[a]
+c = 2
+
+# ERRORE
+[a]
+b = 1
+
+[a.b]
+c = 2
+
+# I nomi delle tabelle non possono essere vuoti.
+[]     # NON VALIDO
+[a.]   # NON VALIDO
+[a..b] # NON VALIDO
+[.b]   # NON VALIDO
+[.]    # NON VALIDO
+
+##################
+# Tabelle inline #
+##################
+
+tabelleInline = { racchiuseData = "{ e }", rigaSingola = true }
+punto = { x = 1, y = 2 }
+
+####################
+# Array di tabelle #
+####################
+
+# Un array di tabelle può essere creato utilizzando due parentesi quadre.
+# Tutte le tabelle con questo nome saranno elementi dell'array.
+# Gli elementi vengono inseriti nell'ordine in cui si trovano.
+
+[[prodotti]]
+nome = "array di tabelle"
+sku = 738594937
+tabelleVuoteValide = true
+
+[[prodotti]]
+
+[[prodotti]]
+nome = "un altro item"
+sku = 284758393
+colore = "grigio"
+
+# Puoi anche creare array di tabelle nested. Le sottotabelle con doppie
+# parentesi quadre apparterranno alla tabella più vicina sopra di esse.
+
+[[frutta]]
+  nome = "mela"
+
+  [frutto.geometria]
+    forma = "sferica"
+    nota = "Sono una proprietà del frutto"
+
+  [[frutto.colore]]
+    nome = "rosso"
+    nota = "Sono un oggetto di un array dentro mela"
+
+  [[frutto.colore]]
+    nome = "verde"
+    nota = "Sono nello stesso array di rosso"
+
+[[frutta]]
+  nome = "banana"
+
+  [[frutto.colore]]
+    nome = "giallo"
+    nota = "Anche io sono un oggetto di un array, ma dentro banana"
+```
+
+Ecco l'equivalente JSON dell'ultima tabella:
+
+```json
+{
+  "frutta": [
+    {
+      "nome": "mela",
+      "geometria": { "forma": "sferica", "nota": "..."},
+      "colore": [
+        { "nome": "rosso", "nota": "..." },
+        { "nome": "verde", "nota": "..." }
+      ]
+    },
+    {
+      "nome": "banana",
+      "colore": [
+        { "nome": "giallo", "nota": "..." }
+      ]
+    }
+  ]
+}
+```
+
+### Altre risorse
+
++ [Repository ufficiale di TOML](https://github.com/toml-lang/toml)