Merge remote-tracking branch 'upstream/master'

Conflicts:
	perl6.html.markdown

3 files changed, 1057 insertions, 0 deletions

diff --git a/it-it/bash-it.html.markdown b/it-it/bash-it.html.markdown
new file mode 100644
index 00000000..f892845f
--- /dev/null
+++ b/it-it/bash-it.html.markdown
@@ -0,0 +1,275 @@
+---
+category: tool
+tool: bash
+contributors:
+    - ["Max Yankov", "https://github.com/golergka"]
+    - ["Darren Lin", "https://github.com/CogBear"]
+    - ["Alexandre Medeiros", "http://alemedeiros.sdf.org"]
+    - ["Denis Arh", "https://github.com/darh"]
+    - ["akirahirose", "https://twitter.com/akirahirose"]
+    - ["Anton Strömkvist", "http://lutic.org/"]
+    - ["Rahil Momin", "https://github.com/iamrahil"]
+    - ["Gregrory Kielian", "https://github.com/gskielian"]
+filename: LearnBash.sh
+translators:
+    - ["Robert Margelli", "http://github.com/sinkswim/"]
+lang: it-it
+---
+
+Bash è il nome della shell di unix, la quale è stata distribuita anche come shell del sistema oprativo GNU e la shell di default su Linux e Mac OS X.
+Quasi tutti gli esempi sottostanti possono fare parte di uno shell script o eseguiti direttamente nella shell.
+
+[Per saperne di piu'.](http://www.gnu.org/software/bash/manual/bashref.html)
+
+```bash
+#!/bin/bash
+# La prima riga dello script è lo shebang il quale dice al sistema come eseguire
+# lo script: http://it.wikipedia.org/wiki/Shabang
+# Come avrai già immaginato, i commenti iniziano con #. Lo shebang stesso è un commento.
+
+# Semplice esempio ciao mondo:
+echo Ciao mondo!
+
+# Ogni comando inizia su una nuova riga, o dopo un punto e virgola:
+echo 'Questa è la prima riga'; echo 'Questa è la seconda riga'
+
+# Per dichiarare una variabile:
+VARIABILE="Una stringa"
+
+# Ma non così:
+VARIABILE = "Una stringa"
+# Bash stabilirà che VARIABILE è un comando da eseguire e darà un errore
+# perchè non esiste.
+
+# Usare la variabile:
+echo $VARIABILE
+echo "$VARIABILE"
+echo '$VARIABILE'
+# Quando usi la variabile stessa - assegnala, esportala, oppure — scrivi
+# il suo nome senza $. Se vuoi usare il valore della variabile, devi usare $.
+# Nota che ' (singolo apice) non espande le variabili!
+
+# Sostituzione di stringhe nelle variabili
+echo ${VARIABILE/Una/A}
+# Questo sostituirà la prima occorrenza di "Una" con "La"
+
+# Sottostringa di una variabile
+echo ${VARIABILE:0:7}
+# Questo ritornerà solamente i primi 7 caratteri
+
+# Valore di default per la variabile
+echo ${FOO:-"ValoreDiDefaultSeFOOMancaOÈ Vuoto"}
+# Questo funziona per null (FOO=), stringa vuota (FOO=""), zero (FOO=0) ritorna 0
+
+# Variabili builtin:
+# Ci sono delle variabili builtin molto utili, come
+echo "Valore di ritorno dell'ultimo programma eseguito: $?"
+echo "PID dello script: $$"
+echo "Numero di argomenti: $#"
+echo "Argomenti dello script: $@"
+echo "Argomenti dello script separati in variabili distinte: $1 $2..."
+
+# Leggere un valore di input:
+echo "Come ti chiami?"
+read NOME # Nota che non abbiamo dovuto dichiarare una nuova variabile
+echo Ciao, $NOME!
+
+# Classica struttura if:
+# usa 'man test' per maggiori informazioni sulle condizionali
+if [ $NOME -ne $USER ]
+then
+    echo "Il tuo nome non è lo username"
+else
+    echo "Il tuo nome è lo username"
+fi
+
+# C'è anche l'esecuzione condizionale
+echo "Sempre eseguito" || echo "Eseguito solo se la prima condizione fallisce"
+echo "Sempre eseguito" && echo "Eseguito solo se la prima condizione NON fallisce"
+
+# Per usare && e || con l'if, c'è bisogno di piu' paia di parentesi quadre:
+if [ $NOME == "Steve" ] && [ $ETA -eq 15 ]
+then
+    echo "Questo verrà eseguito se $NOME è Steve E $ETA è 15."
+fi
+
+if [ $NOME == "Daniya" ] || [ $NOME == "Zach" ]
+then
+    echo "Questo verrà eseguito se $NAME è Daniya O Zach."
+fi
+
+# Le espressioni sono nel seguente formato:
+echo $(( 10 + 5 ))
+
+# A differenza di altri linguaggi di programmazione, bash è una shell - quindi lavora nel contesto
+# della cartella corrente. Puoi elencare i file e le cartelle nella cartella
+# corrente con il comando ls:
+ls
+
+# Questi comandi hanno opzioni che controllano la loro esecuzione:
+ls -l # Elenca tutti i file e le cartelle su una riga separata
+
+# I risultati del comando precedente possono essere passati al comando successivo come input.
+# Il comando grep filtra l'input con il pattern passato. Ecco come possiamo elencare i
+# file .txt nella cartella corrente:
+ls -l | grep "\.txt"
+
+# Puoi redirezionare l'input e l'output del comando (stdin, stdout, e stderr).
+# Leggi da stdin finchè ^EOF$ e sovrascrivi hello.py con le righe
+# comprese tra "EOF":
+cat > hello.py << EOF
+#!/usr/bin/env python
+from __future__ import print_function
+import sys
+print("#stdout", file=sys.stdout)
+print("#stderr", file=sys.stderr)
+for line in sys.stdin:
+    print(line, file=sys.stdout)
+EOF
+
+# Esegui hello.py con diverse redirezioni stdin, stdout, e stderr:
+python hello.py < "input.in"
+python hello.py > "output.out"
+python hello.py 2> "error.err"
+python hello.py > "output-and-error.log" 2>&1
+python hello.py > /dev/null 2>&1
+# Lo output error sovrascriverà il file se esiste,
+# se invece vuoi appendere usa ">>":
+python hello.py >> "output.out" 2>> "error.err"
+
+# Sovrascrivi output.txt, appendi a error.err, e conta le righe:
+info bash 'Basic Shell Features' 'Redirections' > output.out 2>> error.err
+wc -l output.out error.err
+
+# Esegui un comando e stampa il suo file descriptor (esempio: /dev/fd/123)
+# vedi: man fd
+echo <(echo "#ciaomondo")
+
+# Sovrascrivi output.txt con "#helloworld":
+cat > output.out <(echo "#helloworld")
+echo "#helloworld" > output.out
+echo "#helloworld" | cat > output.out
+echo "#helloworld" | tee output.out >/dev/null
+
+# Pulisci i file temporanei verbosamente (aggiungi '-i' per la modalità interattiva)
+rm -v output.out error.err output-and-error.log
+
+# I comandi possono essere sostituiti con altri comandi usando $( ):
+# Il comando seguente mostra il numero di file e cartelle nella
+# cartella corrente.
+echo "Ci sono $(ls | wc -l) oggetti qui."
+
+# Lo stesso puo' essere usato usando backticks `` ma non possono essere innestati - il modo migliore
+# è usando $( ).
+echo "Ci sono `ls | wc -l` oggetti qui."
+
+# Bash utilizza uno statemente case che funziona in maniera simile allo switch in Java e C++:
+case "$VARIABILE" in 
+    #Lista di pattern per le condizioni che vuoi soddisfare
+    0) echo "C'è uno zero.";;
+    1) echo "C'è un uno.";;
+    *) echo "Non è null.";;
+esac
+
+# I cicli for iterano per ogni argomento fornito:
+# I contenuti di $VARIABILE sono stampati tre volte.
+for VARIABILE in {1..3}
+do
+    echo "$VARIABILE"
+done
+
+# O scrivilo con il "ciclo for tradizionale":
+for ((a=1; a <= 3; a++))
+do
+    echo $a
+done
+
+# Possono essere usati anche per agire su file..
+# Questo eseguirà il comando 'cat' su file1 e file2
+for VARIABILE in file1 file2
+do
+    cat "$VARIABILE"
+done
+
+# ..o dall'output di un comando
+# Questo eseguirà cat sull'output di ls.
+for OUTPUT in $(ls)
+do
+    cat "$OUTPUT"
+done
+
+# while loop:
+while [ true ]
+do
+    echo "corpo del loop..."
+    break
+done
+
+# Puoi anche definire funzioni
+# Definizione:
+function foo ()
+{
+    echo "Gli argomenti funzionano come gli argomenti dello script: $@"
+    echo "E: $1 $2..."
+    echo "Questa è una funzione"
+    return 0
+}
+
+# o semplicemente
+bar ()
+{
+    echo "Un altro modo per dichiarare funzioni!"
+    return 0
+}
+
+# Per chiamare la funzione
+foo "Il mio nome è" $NOME
+
+# Ci sono un sacco di comandi utili che dovresti imparare:
+# stampa le ultime 10 righe di file.txt
+tail -n 10 file.txt
+# stampa le prime 10 righe di file.txt
+head -n 10 file.txt
+# ordina le righe di file.txt
+sort file.txt
+# riporta o ometti le righe ripetute, con -d le riporta
+uniq -d file.txt
+# stampa solamente la prima colonna prima del carattere ','
+cut -d ',' -f 1 file.txt
+# sostituisce ogni occorrenza di 'okay' con 'great' in file.txt (compatible con le regex)
+sed -i 's/okay/great/g' file.txt
+# stampa su stdout tutte le righe di file.txt che soddisfano una certa regex
+# L'esempio stampa le righe che iniziano con "foo" e che finiscono con "bar"
+grep "^foo.*bar$" file.txt
+# passa l'opzione "-c" per stampare invece il numero delle righe che soddisfano la regex
+grep -c "^foo.*bar$" file.txt
+# se vuoi letteralmente cercare la stringa,
+# e non la regex, usa fgrep (o grep -F)
+fgrep "^foo.*bar$" file.txt 
+
+
+# Leggi la documentazione dei builtin di bash con il builtin 'help' di bash:
+help
+help help
+help for
+help return
+help source
+help .
+
+# Leggi la manpage di bash con man
+apropos bash
+man 1 bash
+man bash
+
+# Leggi la documentazione con info (? per help)
+apropos info | grep '^info.*('
+man info
+info info
+info 5 info
+
+# Leggi la documentazione di bash:
+info bash
+info bash 'Bash Features'
+info bash 6
+info --apropos bash
+```
diff --git a/it-it/c++-it.html.markdown b/it-it/c++-it.html.markdown
new file mode 100644
index 00000000..e7e1d89e
--- /dev/null
+++ b/it-it/c++-it.html.markdown
@@ -0,0 +1,720 @@
+---
+language: c++
+filename: learncpp-it.cpp
+contributors:
+    - ["Steven Basart", "http://github.com/xksteven"]
+    - ["Matt Kline", "https://github.com/mrkline"]
+translators:
+    - ["Robert Margelli", "http://github.com/sinkswim/"]
+lang: it-it
+---
+
+Il C++ è un linguaggio di programmazione il quale,
+[secondo il suo inventore Bjarne Stroustrup](http://channel9.msdn.com/Events/Lang-NEXT/Lang-NEXT-2014/Keynote),
+è stato progettato per
+
+- essere un "miglior C"
+- supportare l'astrazione dei dati
+- supportare la programmazione orientata agli oggetti
+- supportare la programmazione generica
+
+Nonostante la sintassi possa risultare più difficile o complessa di linguaggi più recenti,
+è usato in maniera vasta poichè viene compilato in istruzioni macchina che possono
+essere eseguite direttamente dal processore ed offre un controllo stretto sull'hardware (come il linguaggio C)
+ed allo stesso tempo offre caratteristiche ad alto livello come i generici, le eccezioni, e le classi.
+Questa combinazione di velocità e funzionalità rende il C++
+uno dei più utilizzati linguaggi di programmazione.
+
+```c++
+//////////////////
+// Confronto con il C
+//////////////////
+
+// Il C++ è _quasi_ un superset del C e con esso condivide la sintassi di base per
+// la dichiarazione di variabili, tipi primitivi, e funzioni.
+
+// Proprio come nel C, l'inizio del programma è una funzione chiamata
+// main con un intero come tipo di ritorno,
+// Questo valore serve come stato d'uscita del programma.
+// Vedi http://it.wikipedia.org/wiki/Valore_di_uscita per maggiori informazioni.
+int main(int argc, char** argv)
+{
+    // Gli argomenti a linea di comando sono passati tramite argc e argv così come
+    // avviene in C.
+    // argc indica il numero di argomenti,
+    // e argv è un array di stringhe in stile-C (char*)
+    // che rappresenta gli argomenti.
+    // Il primo argomento è il nome che è stato assegnato al programma.
+    // argc e argv possono essere omessi se non hai bisogno di argomenti,
+    // in questa maniera la funzione avrà int main() come firma.
+
+    // Lo stato di uscita 0 indica successo.
+    return 0;
+}
+
+// Tuttavia, il C++ varia nei seguenti modi:
+
+// In C++, i caratteri come letterali sono da un byte.
+sizeof('c') == 1
+
+// In C, i caratteri come letterali sono della stessa dimensione degli interi.
+sizeof('c') == sizeof(10)
+
+
+// C++ ha prototipizzazione rigida
+void func(); // funziona che non accetta argomenti
+
+// In C
+void func(); // funzione che può accettare un qualsiasi numero di argomenti
+
+// Usa nullptr invece di NULL in C++
+int* ip = nullptr;
+
+// Gli header C standard sono disponibili in C++,
+// ma sono prefissati con "c" e non hanno il suffisso ".h".
+#include <cstdio>
+
+int main()
+{
+    printf("Ciao, mondo!\n");
+    return 0;
+}
+
+///////////////////////////////
+// Overloading per le funzioni
+//////////////////////////////
+
+// Il C++ supporta l'overloading per le funzioni
+// sia dato che ogni funzione accetta parametri diversi.
+
+void print(char const* myString)
+{
+    printf("Stringa %s\n", myString);
+}
+
+void print(int myInt)
+{
+    printf("Il mio int è %d", myInt);
+}
+
+int main()
+{
+    print("Ciao"); // Viene chiamata void print(const char*)
+    print(15); //  Viene chiamata void print(int)
+}
+
+////////////////////////
+// Argomenti di default
+///////////////////////
+
+// Puoi fornire argomenti di default per una funzione
+// se non sono forniti dal chiamante.
+
+void faiQualcosaConInteri(int a = 1, int b = 4)
+{
+    // fai qualcosa con gli interi qui
+}
+
+int main()
+{
+    faiQualcosaConInteri();      // a = 1,  b = 4
+    faiQualcosaConInteri(20);    // a = 20, b = 4
+    faiQualcosaConInteri(20, 5); // a = 20, b = 5
+}
+
+// Gli argomenti di default devono essere alla fine della lista degli argomenti.
+
+void dichiarazioneInvalida(int a = 1, int b) // Errore!
+{
+}
+
+
+/////////////
+// Namespaces
+/////////////
+
+// I namespaces forniscono visibilità separata per dichiarazioni di variabili, funzioni,
+// ed altro.
+// I namespaces possono essere annidati.
+
+namespace Primo {
+    namespace Annidato {
+        void foo()
+        {
+            printf("Questa è Primo::Annidato::foo\n");
+        }
+    } // fine di namespace Annidato
+} // fine di namespace Primo
+
+namespace Secondo {
+    void foo()
+    {
+        printf("Questa è Secondo::foo\n")
+    }
+}
+
+void foo()
+{
+    printf("Questa è foo globale\n");
+}
+
+int main()
+{
+    // Assume che tutto venga dal namespace "Secondo"
+    // a meno che non venga dichiarato altrimenti.
+    using namespace Secondo;
+
+    foo(); // stampa "Questa è Secondo::foo"
+    Primo::Annidato::foo(); // stampa "Questa è Primo::Annidato::foo"
+    ::foo(); // stampa "Questa è foo globale"
+}
+
+///////////////
+// Input/Output
+///////////////
+
+// L'input e l'output in C++ utilizza gli streams
+// cin, cout, e cerr i quali rappresentano stdin, stdout, e stderr.
+// << è l'operatore di inserzione >> è l'operatore di estrazione.
+
+#include <iostream> // Include gli streams di I/O
+
+using namespace std; // Gli streams sono nel namespace std (libreria standard)
+
+int main()
+{
+   int myInt;
+
+   // Stampa su stdout (o terminalee/schermo)
+   cout << "Inserisci il tuo numero preferito:\n";
+   // Prende l'input
+   cin >> myInt;
+
+   // cout può anche essere formattato
+   cout << "Il tuo numero preferito è " << myInt << "\n";
+   // stampa "Il tuo numero preferito è <myInt>"
+
+    cerr << "Usato per messaggi di errore";
+}
+
+////////////
+// Stringhe
+///////////
+
+// Le stringhe in C++ sono oggetti ed hanno molte funzioni membro
+#include <string>
+
+using namespace std; // Anche le stringhe sono contenute nel namespace std (libreria standard)
+
+string myString = "Ciao";
+string myOtherString = " Mondo";
+
+// + è usato per la concatenazione.
+cout << myString + myOtherString; // "Ciao Mondo"
+
+cout << myString + " Bella"; // "Ciao Bella"
+
+// le stringhe in C++ possono essere modificate.
+myString.append(" Mario");
+cout << myString; // "Ciao Mario"
+
+
+///////////////
+// Riferimenti
+//////////////
+
+// Oltre ai puntatori come quelli in C,
+// il C++ ha i _riferimenti_.
+// Questi non sono tipi puntatori che non possono essere riassegnati una volta settati
+// e non possono essere null.
+// Inoltre, essi hanno la stessa sintassi della variabile stessa:
+// * non è necessario per la dereferenziazione e
+// & ("indirizzo di") non è usato per l'assegnamento.
+
+using namespace std;
+
+string foo = "Io sono foo";
+string bar = "Io sono bar";
+
+
+string& fooRef = foo; // Questo crea un riferimento a foo.
+fooRef += ". Ciao!"; // Modifica foo attraverso il riferimento
+cout << fooRef; // Stampa "Io sono foo. Ciao!"
+
+// Non riassegna "fooRef". Questo è come scrivere "foo = bar", e
+//   foo == "Io sono bar"
+// dopo questa riga.
+fooRef = bar;
+
+const string& barRef = bar; // Crea un riferimento const a bar.
+// Come in C, i valori const (i puntatori e i riferimenti) non possono essere modificati.
+barRef += ". Ciao!"; // Errore, i riferimenti const non possono essere modificati.
+
+//////////////////////////////////////////////////
+// Classi e programmazione orientata agli oggetti
+/////////////////////////////////////////////////
+
+// Primo esempio delle classi
+#include <iostream>
+
+// Dichiara una classe.
+// Le classi sono in genere dichiara in un header file (.h o .hpp).
+class Cane {
+    // Variabili e funzioni membro sono private di default.
+    std::string nome;
+    int peso;
+
+// Tutti i membri dopo questo sono pubblici (public)
+// finchè "private:" o "protected:" non compaiono.
+public:
+
+    // Costruttore di default
+    Cane();
+
+    // Dichiarazioni di funzioni membro (le implentazioni sono a seguito)
+    // Nota che stiamo usando std::string invece di porre
+    // using namespace std;
+    // sopra.
+    // Mai usare uno statement "using namespace" in uno header.
+    void impostaNome(const std::string& nomeCane);
+
+    void impostaPeso(int pesoCane);
+
+    // Le funzioni che non modificano lo stato dell'oggetto
+    // dovrebbero essere marcate come const.
+    // Questo permette di chiamarle con un riferimento const all'oggetto.
+    // Inoltre, nota che le funzioni devono essere dichiarate espliciamente come _virtual_
+    // per essere sovrascritte in classi derivate.
+    // Le funzioni non sono virtual di default per motivi di performance.
+    virtual void print() const;
+
+    // Le funzioni possono essere definite anche all'interno del corpo della classe.
+    // Le funzioni definite in questo modo sono automaticamente inline.
+    void abbaia() const { std::cout << nome << " abbaia!\n"; }
+
+    // Assieme con i costruttori, il C++ fornisce i distruttori.
+    // Questi sono chiamati quando un oggetto è rimosso o esce dalla visibilità.
+    // Questo permette paradigmi potenti come il RAII
+    // (vedi sotto)
+    // I distruttori devono essere virtual per permettere a classi di essere derivate da questa.
+    virtual ~Dog();
+
+}; // Un punto e virgola deve seguire la definizione della funzione
+
+// Le funzioni membro di una classe sono generalmente implementate in files .cpp .
+void Cane::Cane()
+{
+    std::cout << "Un cane è stato costruito\n";
+}
+
+// Gli oggetti (ad esempio le stringhe) devono essere passati per riferimento
+// se li stai modificando o come riferimento const altrimenti.
+void Cane::impostaNome(const std::string& nomeCane)
+{
+    nome = nomeCane;
+}
+
+void Cane::impostaPeso(int pesoCane)
+{
+    peso = pesoCane;
+}
+
+// Notare che "virtual" è solamente necessario nelle dichiarazioni, non nelle definizioni.
+void Cane::print() const
+{
+    std::cout << "Il cane è " << nome << " e pesa " << peso << "kg\n";
+}
+
+void Cane::~Cane()
+{
+    cout << "Ciao ciao " << nome << "\n";
+}
+
+int main() {
+    Cane myDog; // stampa "Un cane è stato costruito"
+    myDog.impostaNome("Barkley");
+    myDog.impostaPeso(10);
+    myDog.print(); // stampa "Il cane è Barkley e pesa 10 kg"
+    return 0;
+} // stampa "Ciao ciao Barkley"
+
+// Ereditarietà:
+
+// Questa classe eredita tutto ciò che è public e protected dalla classe Cane
+class MioCane : public Cane {
+
+    void impostaProprietario(const std::string& proprietarioCane)
+
+    // Sovrascrivi il comportamento della funzione print per tutti i MioCane. Vedi
+    // http://it.wikipedia.org/wiki/Polimorfismo_%28informatica%29
+    // per una introduzione più generale se non sei familiare con
+    // il polimorfismo.
+    // La parola chiave override è opzionale ma fa sì che tu stia effettivamente
+    // sovrascrivendo il metodo nella classe base.
+    void print() const override;
+
+private:
+    std::string proprietario;
+};
+
+// Nel frattempo, nel file .cpp corrispondente:
+
+void MioCane::impostaProprietario(const std::string& proprietarioCane)
+{
+    proprietario = proprietarioCane;
+}
+
+void MioCane::print() const
+{
+    Cane::print(); // Chiama la funzione print nella classe base Cane
+    std::cout << "Il cane è di " << proprietario << "\n";
+    // stampa "Il cane è <nome> e pesa <peso>"
+    //        "Il cane è di <proprietario>"
+}
+
+///////////////////////////////////////////////////
+// Inizializzazione ed Overloading degli Operatori
+//////////////////////////////////////////////////
+
+// In C++ puoi sovrascrivere il comportamento di operatori come +, -, *, /, ecc...
+// Questo è possibile definendo una funzione che viene chiamata
+// ogniqualvolta l'operatore è usato.
+
+#include <iostream>
+using namespace std;
+
+class Punto {
+public:
+    // Così si assegna alle variabili membro un valore di default.
+    double x = 0;
+    double y = 0;
+
+    // Definisce un costruttore di default che non fa nulla
+    // ma inizializza il Punto ai valori di default (0, 0)
+    Punto() { };
+
+    // La sintassi seguente è nota come lista di inizializzazione
+    // ed è il modo appropriato di inizializzare i valori membro della classe
+    Punto (double a, double b) :
+        x(a),
+        y(b)
+    { /* Non fa nulla eccetto inizializzare i valori */ }
+
+    // Sovrascrivi l'operatore +.
+    Punto operator+(const Punto& rhs) const;
+
+    // Sovrascrivi l'operatore +=
+    Punto& operator+=(const Punto& rhs);
+
+    // Avrebbe senso aggiungere gli operatori - e -=,
+    // ma li saltiamo per rendere la guida più breve.
+};
+
+Punto Punto::operator+(const Punto& rhs) const
+{
+    // Crea un nuovo punto come somma di questo e di rhs.
+    return Punto(x + rhs.x, y + rhs.y);
+}
+
+Punto& Punto::operator+=(const Punto& rhs)
+{
+    x += rhs.x;
+    y += rhs.y;
+    return *this;
+}
+
+int main () {
+    Punto su (0,1);
+    Punto destro (1,0);
+    // Questo chiama l'operatore + di Punto
+    // Il Punto su chiama la funzione + con destro come argomento
+    Punto risultato = su + destro;
+    // Stampa "Risultato è spostato in (1,1)"
+    cout << "Risultato è spostato (" << risultato.x << ',' << risultato.y << ")\n";
+    return 0;
+}
+
+/////////////////
+// Templates
+////////////////
+
+// Generalmente i templates in C++ sono utilizzati per programmazione generica, anche se
+// sono molto più potenti dei costrutti generici in altri linguaggi. Inoltre,
+// supportano specializzazione esplicita e parziale, classi in stile funzionale,
+// e sono anche complete per Turing.
+
+// Iniziamo con il tipo di programmazione generica con cui forse sei familiare. Per
+// definire una classe o una funzione che prende un parametro di un dato tipo:
+template<class T>
+class Box {
+    // In questa classe, T può essere usato come qualsiasi tipo.
+    void inserisci(const T&) { ... }
+};
+
+// Durante la compilazione, il compilatore in effetti genera copie di ogni template
+// con i parametri sostituiti, e così la definizione completa della classe deve essere
+// presente ad ogni invocazione. Questo è il motivo per cui vedrai le classi template definite
+// interamente in header files.
+
+// Per instanziare una classe template sullo stack:
+Box<int> intBox;
+
+// e puoi usarla come aspettato:
+intBox.inserisci(123);
+
+//Puoi, ovviamente, innestare i templates:
+Box<Box<int> > boxOfBox;
+boxOfBox.inserisci(intBox);
+
+// Fino al C++11, devi porre uno spazio tra le due '>', altrimenti '>>'
+// viene visto come l'operatore di shift destro.
+
+// Qualche volta vedrai
+// template<typename T>
+// invece. La parole chiavi 'class' e 'typename' sono _generalmente_
+// intercambiabili in questo caso. Per una spiegazione completa, vedi
+// http://en.wikipedia.org/wiki/Typename
+// (si, quella parola chiave ha una sua pagina di Wikipedia propria).
+
+// Similmente, una funzione template:
+template<class T>
+void abbaiaTreVolte(const T& input)
+{
+    input.abbaia();
+    input.abbaia();
+    input.abbaia();
+}
+
+// Nota che niente è specificato relativamente al tipo di parametri. Il compilatore
+// genererà  e poi verificherà il tipo di ogni invocazione del template, così che
+// la funzione di cui sopra funzione con ogni tipo 'T' che ha const 'abbaia' come metodo!
+
+Cane fluffy;
+fluffy.impostaNome("Fluffy")
+abbaiaTreVolte(fluffy); // Stampa "Fluffy abbaia" tre volte.
+
+// I parametri template non devono essere classi:
+template<int Y>
+void stampaMessaggio() {
+  cout << "Impara il C++ in " << Y << " minuti!" << endl;
+}
+
+// E poi esplicitamente specializzare i template per avere codice più efficiente. Ovviamente,
+// la maggior parte delle casistiche reali non sono così triviali.
+// Notare che avrai comunque bisogna di dichiarare la funzione (o classe) come un template
+// anche se hai esplicitamente specificato tutti i parametri.
+template<>
+void stampaMessaggio<10>() {
+  cout << "Impara il C++ più velocemente in soli 10 minuti!" << endl;
+}
+
+printMessage<20>();  // Stampa "impara il C++ in 20 minuti!"
+printMessage<10>();  // Stampa "Impara il C++ più velocemente in soli 10 minuti!"                                   
+                                        
+////////////////////////////
+// Gestione delle eccezioni
+///////////////////////////
+
+// La libreria standard fornisce un paio di tipi d'eccezioni
+// (vedi http://en.cppreference.com/w/cpp/error/exception)
+// ma ogni tipo può essere lanciato come eccezione
+#include <exception>
+
+// Tutte le eccezioni lanciate all'interno del blocco _try_ possono essere catturate dai successivi 
+// handlers _catch_.
+try {
+    // Non allocare eccezioni nello heap usando _new_.
+    throw std::exception("È avvenuto un problema");
+}
+// Cattura le eccezioni come riferimenti const se sono oggetti
+catch (const std::exception& ex)
+{
+  std::cout << ex.what();
+// Cattura ogni eccezioni non catturata dal blocco _catch_ precedente
+} catch (...)
+{
+    std::cout << "Catturata un'eccezione sconosciuta";
+    throw; // Rilancia l'eccezione
+}
+
+///////
+// RAII
+///////
+
+// RAII sta per Resource Allocation Is Initialization.
+// Spesso viene considerato come il più potente paradigma in C++.
+// È un concetto semplice: un costruttore di un oggetto
+// acquisisce le risorse di tale oggetto ed il distruttore le rilascia.
+
+// Per comprendere come questo sia vantaggioso,
+// consideriamo una funzione che usa un gestore di file in C:
+void faiQualcosaConUnFile(const char* nomefile)
+{
+    // Per cominciare, assumiamo che niente possa fallire.
+
+    FILE* fh = fopen(nomefile, "r"); // Apri il file in modalità lettura.
+
+    faiQualcosaConIlFile(fh);
+    faiQualcosAltroConEsso(fh);
+
+    fclose(fh); // Chiudi il gestore di file.
+}
+
+// Sfortunatamente, le cose vengono complicate dalla gestione degli errori.
+// Supponiamo che fopen fallisca, e che faiQualcosaConUnFile e
+// faiQualcosAltroConEsso ritornano codici d'errore se falliscono.
+// (Le eccezioni sono la maniera preferita per gestire i fallimenti,
+//  ma alcuni programmatori, specialmente quelli con un passato in C,
+//  non sono d'accordo con l'utilità delle eccezioni).
+// Adesso dobbiamo verificare che ogni chiamata per eventuali fallimenti e chiudere il gestore di file
+// se un problema è avvenuto.
+bool faiQualcosaConUnFile(const char* nomefile)
+{
+    FILE* fh = fopen(nomefile, "r"); // Apre il file in modalità lettura
+    if (fh == nullptr) // Il puntatore restituito è null in caso di fallimento.
+        return false; // Riporta il fallimento al chiamante.
+
+    // Assumiamo che ogni funzione ritorni false se ha fallito
+    if (!faiQualcosaConIlFile(fh)) {
+        fclose(fh); // Chiude il gestore di file così che non sprechi memoria.
+        return false; // Propaga l'errore.
+    }
+    if (!faiQualcosAltroConEsso(fh)) {
+        fclose(fh); // Chiude il gestore di file così che non sprechi memoria.
+        return false; // Propaga l'errore.
+    }
+
+    fclose(fh); // Chiudi il gestore di file così che non sprechi memoria.
+    return true; // Indica successo
+}
+
+// I programmatori C in genere puliscono questa procedura usando goto:
+bool faiQualcosaConUnFile(const char* nomefile)
+{
+    FILE* fh = fopen(nomefile, "r");
+    if (fh == nullptr)
+        return false;
+
+    if (!faiQualcosaConIlFile(fh))
+        goto fallimento;
+
+    if (!faiQualcosAltroConEsso(fh))
+        goto fallimento;
+
+    fclose(fh); // Chiude il file
+    return true; // Indica successo
+
+fallimento:
+    fclose(fh);
+    return false; // Propaga l'errore
+}
+
+// Se le funzioni indicano errori usando le eccezioni,
+// le cose sono un pò più pulite, ma sono sempre sub-ottimali.
+void faiQualcosaConUnFile(const char* nomefile)
+{
+    FILE* fh = fopen(nomefile, "r"); // Apre il file in modalità lettura
+    if (fh == nullptr)
+        throw std::exception("Non è stato possibile aprire il file.").
+
+    try {
+        faiQualcosaConIlFile(fh);
+        faiQualcosAltroConEsso(fh);
+    }
+    catch (...) {
+        fclose(fh); // Fai sì che il file venga chiuso se si ha un errore.
+        throw; // Poi rilancia l'eccezione.
+    }
+
+    fclose(fh); // Chiudi il file
+    // Tutto è andato bene
+}
+
+// Confronta questo con l'utilizzo della classe C++ file stream (fstream)
+// fstream usa i distruttori per chiudere il file.
+// Come detto sopra, i distruttori sono automaticamente chiamati
+// ogniqualvolta un oggetto esce dalla visibilità.
+void faiQualcosaConUnFile(const std::string& nomefile)
+{
+    // ifstream è l'abbreviazione di input file stream
+    std::ifstream fh(nomefile); // Apre il file
+
+    // Fai qualcosa con il file
+    faiQualcosaConIlFile(fh);
+    faiQualcosAltroConEsso(fh);
+
+} // Il file viene chiuso automaticamente chiuso qui dal distruttore
+
+// Questo ha vantaggi _enormi_:
+// 1. Può succedere di tutto ma
+//    la risorsa (in questo caso il file handler) verrà ripulito.
+//    Una volta che scrivi il distruttore correttamente,
+//    È _impossibile_ scordarsi di chiudere l'handler e sprecare memoria.
+// 2. Nota che il codice è molto più pulito.
+//    Il distruttore gestisce la chiusura del file dietro le scene
+//    senza che tu debba preoccupartene.
+// 3. Il codice è sicuro da eccezioni.
+//    Una eccezione può essere lanciata in qualunque punto nella funzione e la ripulitura
+//    avverrà lo stesso.
+
+// Tutto il codice C++ idiomatico usa RAII in maniera vasta su tutte le risorse.
+// Esempi aggiuntivi includono
+// - Utilizzo della memoria con unique_ptr e shared_ptr
+// - I contenitori - la lista della libreria standard,
+//   vettori (i.e. array auto-aggiustati), mappe hash, e così via
+//   sono tutti automaticamente distrutti con i loro contenuti quando escono dalla visibilità.
+// - I mutex usano lock_guard e unique_lock
+
+///////////////////////
+// Roba divertente
+//////////////////////
+
+// Aspetti del C++ che potrebbero sbalordire i nuovi arrivati (e anche qualche veterano).
+// Questa sezione è, sfortunatamente, selvaggiamente incompleta; il C++ è uno dei linguaggi
+// più facili con cui puoi spararti da solo nel piede.
+
+// Puoi sovrascrivere metodi privati!
+class Foo {
+  virtual void bar();
+};
+class FooSub : public Foo {
+  virtual void bar();  // sovrascrive Foo::bar!
+};
+
+
+// 0 == false == NULL (la maggior parte delle volte)!
+bool* pt = new bool;
+*pt = 0;  // Setta il valore puntato da 'pt' come falso.
+pt = 0;  // Setta 'pt' al puntatore null. Entrambe le righe vengono compilate senza warnings.
+
+// nullptr dovrebbe risolvere alcune di quei problemi:
+int* pt2 = new int;
+*pt2 = nullptr;  // Non compila
+pt2 = nullptr;  // Setta pt2 a null.
+
+// Ma in qualche modo il tipo 'bool' è una eccezione (questo è per rendere compilabile `if (ptr)`.
+*pt = nullptr;  // Questo compila, anche se '*pt' è un bool! 
+
+
+// '=' != '=' != '='!
+// Chiama Foo::Foo(const Foo&) o qualche variante del costruttore di copia.
+Foo f2;
+Foo f1 = f2;
+
+// Chiama Foo::Foo(const Foo&) o qualche variante, ma solo copie di 'Foo' che fanno parte di
+// 'fooSub'. Ogni altro membro di 'fooSub' viene scartato. Questo comportamento
+// orribile viene chiamato "object slicing."
+FooSub fooSub;
+Foo f1 = fooSub;
+
+// Chiama Foo::operator=(Foo&) o una sua variante.
+Foo f1;
+f1 = f2;
+
+```
+Letture consigliate:
+
+Un riferimento aggiornato del linguaggio può essere trovato qui
+<http://cppreference.com/w/cpp>
+
+Risorse addizionali possono essere trovate qui <http://cplusplus.com>
diff --git a/it-it/json-it.html.markdown b/it-it/json-it.html.markdown
new file mode 100644
index 00000000..0c401753
--- /dev/null
+++ b/it-it/json-it.html.markdown
@@ -0,0 +1,62 @@
+---
+
+language: json
+contributors:
+  	- ["Anna Harren", "https://github.com/iirelu"]
+  	- ["Marco Scannadinari", "https://github.com/marcoms"]
+translators:
+    - ["Robert Margelli", "http://github.com/sinkswim/"]
+lang: it-it
+
+---
+
+Dato che JSON è un formato per lo scambio di dati estremamente semplice, questo sarà con molta probabilità
+il più semplice Learn X in Y Minutes.
+
+Nella sua forma più pura JSON non ha commenti, ma molti parser accettano
+commenti in stile C (//, /\* \*/). Per lo scopo prefissato, tuttavia, tutto sarà
+100% JSON valido. Fortunatamente, si spiega da sè.
+
+```json
+{
+  "chiave": "valore",
+  
+  "chiavi": "devono sempre essere racchiuse tra doppi apici",
+  "numeri": 0,
+  "stringhe": "Ciaø, møndø. Tutti gli unicode sono permessi, assieme con l \"escaping\".",
+  "ha booleani?": true,
+  "il nulla": null,
+
+  "numero grande": 1.2e+100,
+
+  "oggetti": {
+    "commento": "La maggior parte della tua struttura viene dagli oggetti.",
+
+    "array": [0, 1, 2, 3, "Gli array possono contenere qualsiasi cosa.", 5],
+
+    "un altro oggetto": {
+      "commento": "Queste cose possono essere annidate, molto utile."
+    }
+  },
+
+  "sciocchezze": [
+    {
+      "sorgenti di potassio": ["banane"]
+    },
+    [
+      [1, 0, 0, 0],
+      [0, 1, 0, 0],
+      [0, 0, 1, "neo"],
+      [0, 0, 0, 1]
+    ]
+  ],
+  
+  "stile alternativo": {
+    "commento": "Guarda quà!"
+  , "posizione della virgola": "non conta - fintantochè è prima del valore, allora è valida"
+  , "un altro commento": "che bello"
+  },
+
+  "è stato molto breve": "Ed hai finito. Adesso sai tutto cio che JSON ha da offrire."
+}
+```