Completed the Italian translations for the remote levels

src/levels/remote/clone.js

@@ -979,7 +979,7 @@ exports.level = {
               "",
               "Finora, Learn Git Branching si è focalizzato nell'insegnare le basi del lavoro _locale_ sui repository (creazione di rami, fusione, rebasing, etc). Tuttavia, ora che vogliamo esplorare il lavoro con i repository remoti, abbiamo bisogno di un comando per impostare l'ambiente per tali lezioni. Questo comando sarà `git clone`.",
               "",
-              "Tecnicamente, `git clone` nel mondo reale è il comando che userai per creare copie _locali_ di repository remoti (da github per esempio). In Learn Git Branching, però, useremo questo comando in modo leggermente diverso -- `git clone` creerà un repository remoto a partire da quello tuo locale. E' chiaro che questo è il significato tecnicamente opposto del comando reale, ma questo aiuta nel costruire la connessione tra il cloning e il lavoro sui repository remoti, quindi utilizziamo così per ora.",
+              "Tecnicamente, `git clone` nel mondo reale è il comando che userai per creare copie _locali_ di repository remoti (da github per esempio). In Learn Git Branching, però, useremo questo comando in modo leggermente diverso -- `git clone` creerà un repository remoto a partire da quello tuo locale. E' chiaro che questo è il significato tecnicamente opposto del comando reale, ma questo aiuta nel costruire la connessione tra il cloning e il lavoro sui repository remoti, quindi per ora lo utilizzeremo così.",
               ""
             ]
           }

src/levels/remote/fakeTeamwork.js

@@ -19,6 +19,7 @@ exports.level = {
     "vi": "Giả lập làm việc nhóm",
     "sl_SI": "Lažno Ekipno Delo",
     "pl": "Symulacja pracy zespołowej",
+    "it_IT": "Simulare il lavoro di squadra"
   },
   "hint": {
     "en_US": "remember you can specify the number of commits to fake",
@@ -37,6 +38,7 @@ exports.level = {
     "vi": "Nhớ rằng bạn có thể chỉ định số lượng commit để giả lập.",
     "sl_SI": "Spomni se, da lahko določiš število lažnih commitov.",
     "pl": "Pamiętaj, że możesz określić liczbę symulowanych commitów",
+    "it_IT": "Tieni a mente che puoi specificare il numero di commit da simulare"
   },
   "startDialog": {
     "en_US": {
@@ -905,5 +907,59 @@ exports.level = {
         }
       ]
     },
+    "it_IT": {
+      "childViews": [
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "## Simulare la cooperazione",
+              "",
+              "La questione è la seguente -- per alcune delle prossime lezioni, dovremo insegnarti come recuperare delle modifiche effettuate al repository remoto.",
+              "",
+              "Questo significa che dobbiamo essenzialmente \"far finta\" che quest'ultimo sia stato aggiornato da uno dei nostri colleghi / amici / collaboratori, a volte in un certo ramo o per un certo numero di commit.",
+              "",
+              "Per fare ciò, abbiamo introdotto un comando ad hoc: `git fakeTeamwork`. È abbastanza autoesplicativo, vediamo una demo..."
+            ]
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "Il comportamento predefinito di `fakeTeamwork` consiste semplicemente nell'effettuare un commit sul main."
+            ],
+            "afterMarkdowns": [
+              "Ecco qua -- il repository remoto è stato aggiornato con un nuovo commit, e non lo abbiamo ancora scaricato in quanto non abbiamo eseguito `git fetch`."
+            ],
+            "command": "git fakeTeamwork",
+            "beforeCommand": "git clone"
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "Puoi anche specificare il numero di commit o il ramo su cui effettuali specificandolo nel comando."
+            ],
+            "afterMarkdowns": [
+              "Con un comando abbiamo simulato un nostro collega che invia tre commit al ramo `foo` del repository remoto."
+            ],
+            "command": "git fakeTeamwork foo 3",
+            "beforeCommand": "git branch foo; git clone"
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "I prossimi livelli saranno abbastanza tosti, quindi ti chiediamo un po' di più già da ora.",
+              "",
+              "Crea un repository remoto (con `git clone`), simula alcune modifiche su quel repository, effettua tu un commit, e poi recupera quelle modifiche. È come più lezioni in una!"
+            ]
+          }
+        }
+      ]
+    }
   }
 };

src/levels/remote/fetch.js

@@ -18,7 +18,8 @@ exports.level = {
     "ko": "Git Fetch",
     "vi": "Git Fetch",
     "sl_SI": "Git Fetch",
-    "pl": "Git fetch"
+    "pl": "Git fetch",
+    "it_IT": "Git Fetch"
   },
   "hint": {
     "en_US": "just run git fetch!",
@@ -36,7 +37,8 @@ exports.level = {
     "ko": "그냥 git fetch를 하세요!",
     "vi": "Gõ git fetch là được!",
     "sl_SI": "Le izvedi git fetch!",
-    "pl": "Po prostu uruchom git fetch!"
+    "pl": "Po prostu uruchom git fetch!",
+    "it_IT": "Semplicemente git fetch!"
   },
   "startDialog": {
     "en_US": {
@@ -1206,6 +1208,79 @@ exports.level = {
           }
         }
       ]
+    },
+    "it_IT": {
+      "childViews": [
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "## Git Fetch",
+              "",
+              "Lavorare con git remoto consiste essenzialmente nel trasferimento di dati _verso_ e _da_ altri repository. Fino a che possiamo inviare commit avanti e indietro, possiamo condividere qualsiasi tipo di aggiornamento tracciabile da git (e quindi condividere lavoro, nuovi file, nuove idee, letterine d'amore, etc.).",
+              "",
+              "In questa lezione vedremo come recuperare dati _da_ un repository remoto -- il comando per fare ciò è `git fetch`.",
+              "",
+              "Man mano che aggiorneremo la nostra rappresentazione del repository remoto, noterai che i nostri rami _remoti_ si aggiorneranno per riflettere quella nuova rappresentazione. Questo si collega alla lezione precedente sui rami remoti."
+            ]
           }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "Prima di addentrarci nei dettagli di `git fetch`, vediamolo in azione! Qui abbiamo un repository remoto contenente due commit che il nostro repository locale non ha."
+            ],
+            "afterMarkdowns": [
+              "Ecco fatto! I commit `C2` e `C3` sono stati scaricati nel nostro repository locale, e il nostro ramo remoto `o/main` è stato aggiornato per riflettere questo cambiamento."
+            ],
+            "command": "git fetch",
+            "beforeCommand": "git clone; git fakeTeamwork 2"
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "### Cosa fa git fetch",
+              "",
+              "`git fetch` compie unicamente queste due azioni:",
+              "",
+              "* scarica i commit presenti in remoto ma assenti dal nostro repository locale, e...",
+              "* aggiorna dove puntano i nostri rami remoti (ad esempio, `o/main`)",
+              "",
+              "`git fetch` essenzialmente porta la nostra rappresentazione _locale_ del repository remoto al pari con lo stato _attuale_ dello stesso (in questo momento).",
+              "",
+              "Se ti ricordi, nella lezione precedente abbiamo visto che i rami remoti riflettono lo stato del repository remoto dall'_ultima volta_ in cui hai comunicato con esso. `git fetch` è il modo per comunicare con i repository remoti! Ora il legame tra i rami remoti e `git fetch` dovrebbe essere più chiaro.",
+              "",
+              "`git fetch` generalmente comunica con il repository remoto attraverso Internet (tramite un protocollo come `http://` o `git://`).",
+              ""
+            ]
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "### Cosa non fa git fetch",
+              "",
+              "`git fetch`, però, non effettua modifiche a ciò che è già presente in locale sul _tuo_ sistema. Non aggiornerà il tuo ramo `main` e non apporterà modifiche ai tuoi file.",
+              "",
+              "Questo è importante da comprendere in quanto molti sviluppatori pensano che eseguire `git fetch` porterà il loro lavoro a riflettere lo stato del repository remoto. Va a scaricare tutti i dati necessari per farlo, ma _non_ va a modificare effettivamente alcun file locale. Impareremo nelle prossime lezioni i comandi per fare proprio questo :D",
+              "",
+              "In fin dei conti, puoi considerare `git fetch` come una fase di download di dati."
+            ]
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "Per completare il livello, digita `git fetch` per scaricare tutti i commit!"
+            ]
+          }
+        }
+      ]
+    },
   }
 };

src/levels/remote/fetchArgs.js

@@ -18,7 +18,8 @@ exports.level = {
     "uk": "Аргументи для fetch",
     "vi": "Tham số fetch",
     "sl_SI": "Fetch argumenti",
-    "pl": "Argumenty fetch"
+    "pl": "Argumenty fetch",
+    "it_IT": "Parametri di git fetch"
   },
   "hint": {
     "en_US": "Pay attention how the commit ids may have swapped! You can read slides again with \"help level\"",
@@ -36,7 +37,8 @@ exports.level = {
     "uk": "Зверни увагу на те, що номери комітів можуть змінюватися! Слайди уроку можна переглянути ще раз командою \"help level\"",
     "vi": "Lưu ý id của các commit bị tráo đổi, bạn có thể dùng \"help level\" để đọc lại hội thoại",
     "sl_SI": "Bodi pozoren kako so se commit id-ji morda zamenjali! Ponovno lahko prebereš navodila z \"help level\".",
-    "pl": "Zauważ, że identyfikatory commitów mogły zostać zamienione! Slajdy możesz przeczytać jeszcze raz po wpisaniu: \"help level\""
+    "pl": "Zauważ, że identyfikatory commitów mogły zostać zamienione! Slajdy możesz przeczytać jeszcze raz po wpisaniu: \"help level\"",
+    "it_IT": "Fai attenzione, alcuni ID dei commit potrebbero essere invertiti! Puoi leggere nuovamente le slide con \"help level\""
   },
   "startDialog": {
     "en_US": {
@@ -2021,6 +2023,129 @@ exports.level = {
           }
         }
       ]
+    },
+    "it_IT": {
+      "childViews": [
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "## Parametri di git fetch",
+              "",
+              "Abbiamo imparato un sacco sui parametri di git push, su questo bel `<place>`, e persino sui colon refspec (`<source>:<destination>`). Possiamo usare tutta questa conoscenza anche per `git fetch`?",
+              "",
+              "Ma certo! I parametri di `git fetch` sono *molto, molto* simili a quelli di `git push`. È lo stesso tipo di concetto ma applicato nel verso opposto (in quanto ora stai scaricando commit invece che caricarli in un repository remoto).",
+              "",
+              "Vediamo i vari concetti uno per volta..."
+            ]
           }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "### Il parametro `<place>`",
+              "",
+              "Se specifici un luogo con git fetch come nel comando seguente:",
+              "",
+              "`git fetch origin foo`",
+              "",
+              "Git andrà al ramo `foo` sul remoto, prenderà tutti i commit che non sono presenti in locale, e li andrà a mettere nel ramo locale `o/foo`.",
+              "",
+              "Vediamolo in azione (per rinfrescare le idee)."
+            ]
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "Specificando un luogo..."
+            ],
+            "afterMarkdowns": [
+              "Scarichiamo solamente i commit da `foo` e li piazziamo su `o/foo`."
+            ],
+            "command": "git fetch origin foo",
+            "beforeCommand": "git branch foo; git clone; git fakeTeamwork foo 2"
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "Potresti domandarti -- perché git ha messo i commit sul ramo remoto `o/foo` invece che metterli sul mio ramo locale `foo`? Il parametro `<place>` non era un luogo esistente sia localmente che sul remoto?",
+              "",
+              "Git fa un'eccezione in questo caso dato che potresti avere del lavoro sul ramo `foo` che non vuoi venga messo a rischio!! Questo si collega alla vecchia lezione su `git fetch` -- non aggiorna i tuoi rami locali, non-remoti, va solo a scaricare i commit (così che sia tu ad esaminarli / fonderli più avanti).",
+              ""
+            ]
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "\"Bene allora, cosa succede se definisco esplicitamente sia la fonte che la destinazione con `<source>:<destination>`?\"",
+              "",
+              "Se ti senti abbastanza ispirato da voler scaricare commit *direttamente* su di un ramo locale, allora sì, puoi farlo con un colon refspec. Non puoi scaricare commit sul ramo nel quale sei attualmente, a parte questo git te lo permetterà.",
+              "",
+              "Qui c'è la fregatura però -- `<source>` è ora un luogo sul repository *remoto* e `<destination>` è un luogo *locale* nel quale piazzare i commit recuperati. È l'esatto opposto di git push, il che ha senso dato che stiamo trasferendo dati nella direzione opposta!",
+              "",
+              "Detto ciò, gli sviluppatori raramente lo fanno. Lo sto introducendo principalmente come metodo per concettualizzare come `fetch` e `push` siano molto simili, solo in direzioni opposte."
+            ]
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "Vediamo questa pazzia sul campo:"
+            ],
+            "afterMarkdowns": [
+              "Wow! Vediamo, git ha risolto `foo~1` come un luogo sul repository remoto e ha poi scaricato quei commit su `bar` (nostro ramo locale). Notiamo come `foo` e `o/foo` non sono stati aggiornati in quanto abbiamo specificato una destinazione."
+            ],
+            "command": "git fetch origin foo~1:bar",
+            "beforeCommand": "git branch foo; git clone; git branch bar; git fakeTeamwork foo 2"
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "E se la destinazione non esistesse nel momento in cui eseguo il comando? Vediamo la slide precedente ma con l'assenza del ramo `bar`."
+            ],
+            "afterMarkdowns": [
+              "Visto, è PROPRIO come git push. Git ha creato la destinazione in locale prima di recuperare i dati, allo stesso modo in cui avrebbe creato la destinazione in remoto prima di caricarli con push (in caso non esista)."
+            ],
+            "command": "git fetch origin foo~1:bar",
+            "beforeCommand": "git branch foo; git clone; git fakeTeamwork foo 2"
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "Senza parametri?",
+              "",
+              "Se `git fetch` non riceve parametri, scarica semplicemente tutti i commit dal repository remoto su tutti i rami remoti..."
+            ],
+            "afterMarkdowns": [
+              "Abbastanza semplice, ma vale la pena darci almeno un'occhiata."
+            ],
+            "command": "git fetch",
+            "beforeCommand": "git branch foo; git clone; git fakeTeamwork foo; git fakeTeamwork main"
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "Abbiamo parlato abbastanza! Per finire questo livello, scarica solo i commit specificati nella finestra dell'obiettivo. Scatenati con quei comandi!",
+              "",
+              "Dovrai specificare la fonte e la destinazione per entrambi i comandi di fetch. Presta attenzione alla finestra obiettivo in quanto gli ID dei commit potrebbero essere scambiati!"
+            ]
+          }
+        }
+      ]
+    },
   }
 };

src/levels/remote/fetchRebase.js

@@ -18,7 +18,8 @@ exports.level = {
     "ko": "엇갈린 히스토리",
     "vi": "Dị biệt lịch sử",
     "sl_SI": "Razdeljena Zgodovina",
-    "pl": "Rozbieżna  historia"
+    "pl": "Rozbieżna  historia",
+    "it_IT": "Storico divergente"
   },
   "hint": {
     "en_US": "check out the ordering from the goal visualization",
@@ -37,6 +38,7 @@ exports.level = {
     "vi": "kiểm tra kỹ thứ tự trên mô hình mục tiêu",
     "sl_SI": "Preveri vrstni red iz ciljne vizualizacije.",
     "pl": "Przyjrzyj się kolejności na wizualizacji celu",
+    "it_IT": "Controlla l'ordinamento dalla schermata dell'obiettivo"
   },
   "startDialog": {
     "en_US": {
@@ -2327,5 +2329,148 @@ exports.level = {
         }
       ]
     },
+    "it_IT": {
+      "childViews": [
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "## Storico divergente",
+              "",
+              "Fin'ora abbiamo visto come usare `pull` per scaricare commit di altri e come usare `push` per caricare le nostre modifiche. Sembra abbastanza semplice, come fanno le persone a confondersi?",
+              "",
+              "La difficoltà si presenta quando lo storico dei repository *diverge*. Prima di discuterne nel dettaglio, vediamo un esempio...",
+              ""
+            ]
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "Immagina di clonare un repository di lunedì e di iniziare a lavorare su una nuova funzionalità. È arrivato venerdì e sei pronto a pubblicare la tua nuova feature -- ma oh no! I tuoi colleghi hanno scritto del codice durante la settimana che ha resto la tua feature obsoleta. Inoltre, hanno pubblicato questi commit sul repository remoto, quindi ora il *tuo* lavoro è basato su una versione *vecchia* del progetto che non è più rilevante.",
+              "",
+              "In questo caso, il comando `git push` è ambiguo. Eseguendo `git push`, git dovrebbe far tornare il repository remoto a come si trovava di lunedì? Dovrebbe cercare di aggiungere le tue modifiche senza rimuovere quelle dei colleghi? O dovrebbe ignorare totalmente le tue modifiche in quanto obsolete?",
+              "",
+              "Per via di questa ambiguità (dove gli storici divergono), git non ti permette di usare `push` per caricare le tue modifiche. Ti obbliga a scaricare la versione più recente del repository remoto prima di permetterti di condividere il tuo lavoro."
+            ]
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "Tutto questo parlare! Vediamo questa situazione dal vivo."
+            ],
+            "afterMarkdowns": [
+              "Visto? Non è successo nulla in quanto il comando fallisce. `git push` fallisce in quanto il tuo commit più recente, `C3`, è basato sullo stato del repository remoto a `C1`. Nel mentre però il remoto è stato aggiornato a `C2`, quindi git non accetta il tuo push."
+            ],
+            "command": "git push",
+            "beforeCommand": "git clone; git fakeTeamwork; git commit"
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "Come puoi risolvere questa situazione? È facile, tutto ciò che devi fare è far sì che il tuo lavoro sia basato sulla versione più recente del ramo remoto.",
+              "",
+              "Ci sono più modi per fare ciò, il più diretto dei quali è lo spostare il tuo lavoro tramite rebase. Diamo un'occhiata a come si fa."
+            ]
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "Ora se ribasiamo prima di caricare il nostro lavoro..."
+            ],
+            "afterMarkdowns": [
+              "Boom! Abbiamo aggiornato la nostra rappresentazione del remoto tramite `git fetch`, ribasato il nostro lavoro affinché rifletta i nuovi cambiamenti del remoto, e poi li abbiamo caricati con `git push`."
+            ],
+            "command": "git fetch; git rebase o/main; git push",
+            "beforeCommand": "git clone; git fakeTeamwork; git commit"
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "Ci sono altri modi per aggiornare il mio lavoro quando il repository remoto è stato modificato? Certamente! Diamo un'occhiata alla stessa situazione sfruttando invece il `merge`.",
+              "",
+              "Nonostante `git merge` non sposti il tuo lavoro (in quanto va a creare un commit di merge), è un modo per far vedere a git che tutte le modifiche del repository remoto sono state incorporate. Questo in quanto il ramo remoto è ora un *antenato* del tuo ramo locale, per cui il tuo commit comprende tutti i cambiamenti presenti nel ramo remoto.",
+              "",
+              "Vediamolo in azione..."
+            ]
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "Ora se usiamo merge invece di ribasare..."
+            ],
+            "afterMarkdowns": [
+              "Boom! Abbiamo aggiornato la nostra rappresentazione del remoto con `git fetch`, *fuso* le nuove modifiche al nostro lavoro (per riflettere i cambiamenti del remoto), e caricato quest'ultimo con `git push`."
+            ],
+            "command": "git fetch; git merge o/main; git push",
+            "beforeCommand": "git clone; git fakeTeamwork; git commit"
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "Fantastico! C'è per caso un modo per farlo senza dover digitare tutti questi comandi?",
+              "",
+              "Certamente -- sai già che `git pull` è una scorciatoria per fetch e merge. Possiamo digitare `git pull --rebase` come scorciatoia per un fetch e un rebase, molto comodo!",
+              "",
+              "Vediamo questi comandi al lavoro."
+            ]
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "Prima con `--rebase`..."
+            ],
+            "afterMarkdowns": [
+              "Identico a prima! Solo molto più breve."
+            ],
+            "command": "git pull --rebase; git push",
+            "beforeCommand": "git clone; git fakeTeamwork; git commit"
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "E ora con un normale `pull`."
+            ],
+            "afterMarkdowns": [
+              "Di nuovo, esattamente uguale a prima!"
+            ],
+            "command": "git pull; git push",
+            "beforeCommand": "git clone; git fakeTeamwork; git commit"
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "Questo flusso di lavoro di recuperare cambiamenti, ribasare/fondere, e caricare il proprio lavoro è molto comune. Nelle lezioni future esamineremo delle versioni più complicate di questi flussi di lavoro, ma per ora proviamo a fare questo.",
+              "",
+              "Per risolvere il livello, compi i seguenti passi:",
+              "",
+              "* Clona il tuo repository",
+              "* Simula del lavoro da parte di altri (1 commit)",
+              "* Effettua tu delle modifiche (1 commit)",
+              "* Pubblica il tuo lavoro tramite *rebase*"
+            ]
+          }
+        }
+      ]
+    }
   }
 };

src/levels/remote/lockedMain.js

@@ -17,7 +17,8 @@ exports.level = {
     "es_AR": "Crea la rama feature desde la rama main en local antes de restablecerlo para que sea el mismo que la rama main de origen.",
     "ja": "mainブランチをoriginのmainと同じ状態になるようにリセットする前に、ローカルのmainからfeatureブランチを作成します。",
     "pl": "Stwórz boczną gałąź tematyczną (feature) z lokalnego main, a późnej zsynchronizuj ją z main na origin",
-    "vi": "Tạo những nhánh tính năng từ nhánh địa phương trước khi trả chúng về lại giống như o/main"
+    "vi": "Tạo những nhánh tính năng từ nhánh địa phương trước khi trả chúng về lại giống như o/main",
+    "it_IT": "Crea il ramo per la feature a partire dal main locale prima di resettarlo al pari del main remoto"
   },
   "name": {
     "en_US": "Locked Main",
@@ -34,7 +35,8 @@ exports.level = {
     "es_AR": "Main bloqueado",
     "ja": "ロックされたmain",
     "pl": "Zablokowany main",
-    "vi": "Nhánh chính bị khóa (Locked Main)"
+    "vi": "Nhánh chính bị khóa (Locked Main)",
+    "it_IT": "Main bloccato"
   },
   "startDialog": {
     "en_US": {
@@ -654,5 +656,45 @@ exports.level = {
         }
       ]
     },
+    "it_IT": {
+      "childViews": [
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "## Rifiuto remoto!",
+              "",
+              "Se fari parte di un team di grandi dimensioni è probabile che il main sia bloccato e che richieda un processo di Pull Request per fondere il proprio lavoro. Se effettui localmente un commit al main e provi a caricare le modifiche al repository remoto troverai come risposta un messaggio di questo tipo:",
+              "",
+              "```",
+              " ! [remote rejected] main -> main (TF402455: Pushes to this branch are not permitted; you must use a pull request to update this branch.)",
+              "```"
+            ]
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "## Perché è stato rifiutato?",
+              "",
+              "Il repository remoto ha rifiutato l'invio di commit direttamente al main in quanto per questo ramo è richiesto di effettuare una pull request: una richiesta di includere le nostre modifiche personali nel repository remoto.",
+              "",
+              "Avresti dovuto seguire il processo di creare un nuovo ramo, fare il push di quel ramo ed effettuare una pull request, ma ti sei scordato e hai effettuato il commit direttamente sul main. Ora sei bloccato e non puoi caricare le tue modifiche."
+            ]
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "## La soluzione",
+              "",
+              "Crea un nuovo ramo chiamato feature e carica quest'ultimo sul repository remoto. Inoltre reimposta il tuo ramo main affinché sia al pari con il remoto altrimenti potresti andare in contro a dei problemi la prossima volta che proverai ad effettuare un pull e i commit di qualcun'altro andranno in conflitto con i tuoi."
+            ]
+          }
+        }
+      ]
+    },
   }
 };

src/levels/remote/mergeManyFeatures.js

@@ -18,7 +18,8 @@ exports.level = {
     "uk": "Мердж з віддаленим репозиторієм",
     "vi": "Hợp nhất nhánh từ xa",
     "sl_SI": "Merganje z oddaljenim repozitorijem",
-    "pl": "Scalanie z remote"
+    "pl": "Scalanie z remote",
+    "it_IT": "Fondere in remoto"
   },
   "hint": {
     "en_US": "Pay attention to the goal tree!",
@@ -36,7 +37,8 @@ exports.level = {
     "uk": "Уважно подивись як має виглядати результат!",
     "vi": "Hãy để ý đến cây mục tiêu!",
     "sl_SI": "Poglej si ciljno drevo!",
-    "pl": "Zwróć uwagę, jak wygląda docelowe drzewo!"
+    "pl": "Zwróć uwagę, jak wygląda docelowe drzewo!",
+    "it_IT": "Fai attenzione all'albero nell'obiettivo"
   },
   "compareOnlyMain": true,
   "startDialog": {
@@ -759,6 +761,51 @@ exports.level = {
           }
         }
       ]
+    },
+    "it_IT": {
+      "childViews": [
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "## Perché non fondere?",
+              "",
+              "Per riuscire a caricare nuovi aggiornamenti al repository remoto, serve solamente *incorporare* le modifiche più recenti avvenute sul remoto. Ciò significa che puoi ribasare *oppure* fondere le nuove modifiche al ramo remoto (e.g. `o/main`).",
+              "",
+              "Quindi, se entrambi i metodi sono validi, perché le lezioni si sono concentrate sul ribasare? Perché non c'è amore per il `merge` quando si lavora con i repository remoti?",
+              ""
+            ]
           }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "C'è abbastanza dibattito sui compromessi tra il fondere e il ribasare nell'ambiente degli sviluppatori. Qui presentiamo in generale i pro e contro del ribasare:",
+              "",
+              "Pro:",
+              "",
+              "* Ribasare rende il tuo albero dei commit più semplice da leggere in quanto tutto rientra in una linea dritta",
+              "",
+              "Cons:",
+              "",
+              "* Ribasare modifica lo storico (apparente) dell'albero dei commit.",
+              "",
+              "Ad esempio, il commit `C1` può essere ribasato *dopo* di `C3`. Apparirà che il lavoro per `C1` è avvenuto dopo `C3` quando in realtà era stato completato in precedenza.",
+              "",
+              "Alcuni sviluppatori amano preservare lo storico e perciò prediligono la fusione di commit. Altri (come il sottoscritto) preferiscono avere un albero dei commit più pulito, e perciò preferiscono ribasare. È una questione di gusti :D"
+            ]
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "Per questo livello, prova a risolvere il livello precedente ma usando il *merge* invece che il *rebase*. L'albero apparirà più \"ingarbugliato\", ma dovrebbe riuscire a rendere bene l'idea."
+            ]
+          }
+        }
+      ]
+    },
   }
 };

src/levels/remote/pull.js

@@ -19,6 +19,7 @@ exports.level = {
     "vi": "Git pull",
     "sl_SI": "Git Pull",
     "pl": "Git pull",
+    "it_IT": "Git Pull"
   },
   "hint": {
     "en_US": "Just run git pull!",
@@ -37,6 +38,7 @@ exports.level = {
     "vi": "Đơn giản là gõ git pull!",
     "sl_SI": "Samo izvedi git pull!",
     "pl": "Po prostu uruchom git pull!",
+    "it_IT": "Semplicemente git pull!"
   },
   "startDialog": {
     "en_US": {
@@ -983,5 +985,64 @@ exports.level = {
         }
       ]
     },
+    "it_IT": {
+      "childViews": [
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "## Git Pull",
+              "",
+              "Ora che abbiamo visto come recuperare dati da un repository remoto con `git fetch`, vediamo di aggiornare il nostro repository affinché rifletta questi cambiamenti!",
+              "",
+              "Ci sono più modi per fare ciò -- una volta che i nuovi commit sono disponibili localmente, si possono incorporare come se fossero normali commit da altri rami. Questo significa che possiamo eseguire comandi come:",
+              "",
+              "* `git cherry-pick o/main`",
+              "* `git rebase o/main`",
+              "* `git merge o/main`",
+              "* etc., etc.",
+              "",
+              "Infatti, il metodo del *recuperare* cambiamenti remoti e poi *fonderli* nel nostro repository è talmente comune che git fornisce un comando che compie entrambi i passi in uno! Quel comando è `git pull`."
+            ]
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "Diamo prima un'occhiata a `fetch` e `merge` eseguiti uno dopo l'altro."
+            ],
+            "afterMarkdowns": [
+              "Boom -- abbiamo scaricato `C3` con un `fetch` e poi fuso assieme il lavoro con `git merge o/main`. Ora il nostro ramo `main` riflette le nuove modifiche dal ramo remoto (in questo caso, chiamato `origin`)"
+            ],
+            "command": "git fetch; git merge o/main",
+            "beforeCommand": "git clone; git commit; git fakeTeamwork"
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "Cosa succederebbe se invece usassimo `git pull`?"
+            ],
+            "afterMarkdowns": [
+              "La stessa cosa! Ciò dovrebbe chiarire che `git pull` è essenzialmente una scorciatoia allo scrivere `git fetch` seguito dalla fusione del ramo appena recuperato."
+            ],
+            "command": "git pull",
+            "beforeCommand": "git clone; git commit; git fakeTeamwork"
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "Esploreremo i dettagli di `git pull` più tardi (incluse le opzioni e i parametri), ma per ora proviamo ad usarlo nel livello.",
+              "",
+              "Ricorda -- potresti risolvere questo livello eseguendo `fetch` seguito da `merge`, ma ti costerà un comando in più :P"
+            ]
+          }
+        }
+      ]
+    }
   }
 };

src/levels/remote/pullArgs.js

@@ -18,7 +18,8 @@ exports.level = {
     "uk": "Аргументи pull",
     "vi": "Tham số pull",
     "sl_SI": "Pull argumenti",
-    "pl": "Argumenty pull"
+    "pl": "Argumenty pull",
+    "it_IT": "Parametri di git pull"
   },
   "hint": {
     "en_US": "Remember that you can create new local branches with fetch/pull arguments",
@@ -36,7 +37,8 @@ exports.level = {
     "uk": "Пам'ятай, що ти можеш створювати нові гілки, використовуючи fetch/pull з аргументами",
     "vi": "Nhớ rằng,bạn có thể tạo nhánh cục bộ mới với tham số của fetch/pull",
     "sl_SI": "Zapomni si, da lahko ustvariš nove lokalne branche s fetch/pull argumenti.",
-    "pl": "Pamiętaj, że za pomocą argumentów fetch/pull możesz tworzyć nowe lokalne gałęzie"
+    "pl": "Pamiętaj, że za pomocą argumentów fetch/pull możesz tworzyć nowe lokalne gałęzie",
+    "it_IT": "Ricorda che puoi creare nuovi rami locali sfruttando fetch/pull + parametri"
   },
   "startDialog": {
     "en_US": {
@@ -1231,6 +1233,80 @@ exports.level = {
           }
         }
       ]
+    },
+    "it_IT": {
+      "childViews": [
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "## Parametri di git pull",
+              "",
+              "Ora che conosci praticamente *tutto* quello che c'è da sapere sui parametri per `git fetch` e `git push`, non è rimasto quasi nulla di cui parlare per git pull :)",
+              "",
+              "Questo perché git pull alla fine non è altro che una scorciatoia per un fetch seguito dalla fusione verso ciò che è stato appena recuperato. Puoi vederlo come eseguire git fetch con gli *stessi* parametri specificati e poi eseguire una fusione *dove* i commit reucperati sono finiti.",
+              "",
+              "Ciò è valido anche quando vengono usati dei parametri incredibilmente complessi. Vediamo qualche esempio:"
+            ]
           }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "Ecco alcuni comandi equivalenti in git:",
+              "",
+              "`git pull  origin foo` è equivalente a:",
+              "",
+              "`git fetch origin foo; git merge o/foo`",
+              "",
+              "E...",
+              "",
+              "`git pull  origin bar~1:bugFix` è equivalente a:",
+              "",
+              "`git fetch origin bar~1:bugFix; git merge bugFix`",
+              "",
+              "Visto? git pull non è altro che una scorciatoia per fetch + merge, e l'unica cosa che interessa a quel comando è la posizione d'arrivo dei commit (il parametro `destination` specificato durante il fetch).",
+              "",
+              "Vediamo una demo:"
+            ]
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "Se specifichiamo il luogo da cui vogliamo recuperare i dati, l'unico cambiamento rispetto alla lezione precedente consiste nella fusione con ciò che è stato appena recuperato."
+            ],
+            "afterMarkdowns": [
+              "Visto! specificando `main` abbiamo scaricato i commit sul ramo `o/main` come sempre. Poi abbiamo fuso `o/main` con il ramo sul quale stavamo lavorando attualmente, il quale *non* è il ramo `main` locale. Per questo motivo può avere effettivamente senso eseguire più volte git pull (con gli stessi parametri) da posizioni differenti per aggiornare così più rami."
+            ],
+            "command": "git pull origin main",
+            "beforeCommand": "git clone; go -b bar; git commit; git fakeTeamwork"
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "Funziona anche con source e destination? Ci puoi scommettere! Vediamolo all'opera:"
+            ],
+            "afterMarkdowns": [
+              "Wow, è tantissimo per un comando solo! Abbiamo creato un nuovo ramo locale chiamato `foo`, scaricato i commit dal main remoto sul nuovo ramo `foo`, e poi fuso quel ramo con `bar`, quello sul quale stavamo lavorando attualmente. È oltre gli 8000!!!"
+            ],
+            "command": "git pull origin main:foo",
+            "beforeCommand": "git clone; git fakeTeamwork; go -b bar; git commit"
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "Ok per concludere, raggiungi lo stato mostrato nella finestra dell'obiettivo. Dovrai scaricare alcuni commit, creare alcuni rami, e fondere quei rami in altri rami, ma senza usare troppi comandi :P"
+            ]
+          }
+        }
+      ]
+    },
   }
 };

src/levels/remote/push.js

@@ -21,7 +21,8 @@ exports.level = {
     "ko": "Git push",
     "vi": "Git push",
     "sl_SI": "Git Push",
-    "pl": "Git push"
+    "pl": "Git push",
+    "it_IT": "Git Push"
   },
   "hint": {
     "en_US": "Remember you have to clone before you can push!",
@@ -39,6 +40,7 @@ exports.level = {
     "vi": "Nhớ rằng bạn phải clone trước khi push!",
     "sl_SI": "Najprej moraš klonirati, preden lahko pushaš!",
     "pl": "Najpierw sklonuj, potem pushuj!",
+    "it_IT": "Ricorda di clonare il repository prima di usare push!"
   },
   "startDialog": {
     "en_US": {
@@ -724,5 +726,48 @@ exports.level = {
         }
       ]
     },
+    "it_IT": {
+      "childViews": [
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "## Git Push",
+              "",
+              "Ok, ho recuperato tutti gli aggiornamenti dal repository remoto e li ho incorporati al mio repository locale. Fin qui tutto apposto ma... come faccio a condividere il _mio_ fantastico lavoro con gli altri?",
+              "",
+              "Bene, per caricare il lavoro da condividere si deve fare l'opposto dello scaricarlo. E qual è l'opposto di `git pull`? `git push`!",
+              "",
+              "`git push` è responsabile dell'inviare le _tue_ modifiche ad uno specifico repository remoto e di aggiornarlo per far sì che incorpori i tuoi nuovi commit. Una volta eseguito `git push`, tutti i tuoi amici possono scaricare il tuo lavoro dal repository remoto.",
+              "",
+              "Puoi considerare `git push` come un comando per \"pubblicare\" il tuo lavoro. Ha una serie di sottigliezze che vedremo più avanti, per ora iniziamo dalle basi...",
+              "",
+              "*nota -- il comportamento di `git push` senza argomenti dipende da un'impostazione di git chiamata `push.default`. Il valore predefinito di quest'impostazione dipende dalla versione di git in uso; noi andremo ad usare il valore `upstream` nelle lezioni. Non è un problema, ma vale la pena controllare le impostazioni prima di usare push nei tuoi progetti.*"
+            ]
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "Qui abbiamo alcuni cambiamenti che non sono presenti nel repository remoto. Andiamo a caricarli!"
+            ],
+            "afterMarkdowns": [
+              "Ecco qui -- il repository remoto ha ricevuto il commit `C2`, il ramo `main` sul remoto è stato aggiornato a puntare a `C2`, ed anche il *nostro* riflesso del repository remoto (`o/main`) è stato aggiornato. Tutto è stato sincronizzato!"
+            ],
+            "command": "git push",
+            "beforeCommand": "git clone; git commit"
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "Per terminare questo livello, condividi due nuovi commit con il repository remoto. Preparati però, perché le prossime lezioni saranno belle toste!"
+            ]
+          }
+        }
+      ]
+    }
   }
 };

src/levels/remote/pushArgs.js

@@ -22,7 +22,8 @@ exports.level = {
     "uk": "Аргументи git push",
     "vi": "Tham số git push",
     "sl_SI": "Git push argumenti",
-    "pl": "Argumenty git push"
+    "pl": "Argumenty git push",
+    "it_IT": "Parametri di git push"
   },
   "hint": {
     "en_US": "You can always look at the last slide of the dialog with \"objective\"",
@@ -40,7 +41,8 @@ exports.level = {
     "uk": "Завжди можна подивитися останній слайд діалогу за допомогою \"objective\"",
     "vi": "Bạn có thể sử dụng \"objective\" để đọc trang cuối của cửa sổ hộp thoại",
     "sl_SI": "Vedno lahko pogledaš zadnji dialog z \"objective\".",
-    "pl": "Możesz wpisać \"objective\", żeby zobaczyć ostatni slajd z każdego poziomu"
+    "pl": "Możesz wpisać \"objective\", żeby zobaczyć ostatni slajd z każdego poziomu",
+    "it_IT": "Puoi sempre guardare l'ultima slide del dialogo con \"objective\""
   },
   "startDialog": {
     "en_US": {
@@ -1221,6 +1223,81 @@ exports.level = {
           }
         }
       ]
+    },
+    "it_IT": {
+      "childViews": [
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "## Parametri di git push",
+              "",
+              "Ottimo! Ora che hai presente cos'è il tracciamento remoto dei rami possiamo dare un'occhiata ad alcuni dei misteri dietro al funzionamento di git push, fetch e pull. Affronteremo un comando alla volta ma i concetti tra questi saranno molto simili.",
+              "",
+              "Come prima cosa daremo un'occhiata a `git push`. Hai imparato nella lezione sul tracciamento remoto che git decide il ramo remoto *e* il ramo su cui caricare i dati osservando le proprietà del ramo su cui stiamo lavorando attualmente (il remoto che sta \"tracciando\"). Questo è il comportamento senza parametri aggiunti, ma git push può prendere dei parametri aggiuntivi nella forma di:",
+              "",
+              "`git push <remote> <place>`",
+              "",
+              ""
+            ]
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "E cosa indica il parametro `<place>`? Vedremo presto le specifiche, ma prima un esempio. Il comando:",
+              "",
+              "`git push origin main`",
+              "",
+              "equivale a questo in italiano:",
+              "",
+              "*Vai al ramo chiamato \"main\" nel mio repository locale, prendi tutti i commit, poi vai nel ramo \"main\" sul repository remoto chiamato \"origin\". Mettici tutti i commit che mancano e poi dimmi quando hai finito.*",
+              "",
+              "Specificando `main` come parametro \"place\", abbiamo detto a git da dove tutti i commit *proverranno* e dove i commit *dovranno andare*. Si tratta essenzialmente del \"luogo\" o \"posizione\" da sincronizzare tra i due repository.",
+              "",
+              "Tieni a mente che poiché abbiamo detto a git tutto ciò che gli serve sapere (specificando entrambi i parametri), non tiene conto del ramo sul quale ci troviamo attualmente!"
+            ]
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "Vediamo un esempio dove specifichiamo i parametri. Da notare la posizione su cui ci troviamo attualmente in questo esempio."
+            ],
+            "afterMarkdowns": [
+              "Ecco qui! `main` è stato aggiornato sul repository remoto come specificato dai parametri."
+            ],
+            "command": "git checkout C0; git push origin main",
+            "beforeCommand": "git clone; git commit"
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "E se non avessimo specificato i parametri? Cosa succederebbe?"
+            ],
+            "afterMarkdowns": [
+              "Il comando fallisce (come puoi vedere), in quanto `HEAD` non si trova su un ramo che traccia il remoto."
+            ],
+            "command": "git checkout C0; git push",
+            "beforeCommand": "git clone; git commit"
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "Ok, per questo livello aggiorniamo sia il ramo `foo` che `main` sul remoto. Attenzione perché git checkout è disabilitato per questo livello!",
+              "",
+              "*Nota: I rami remoti hanno i prefissi `o/` perché `origin/` non si adattava bene alla nostra interfaccia. Non preoccuparti ",
+              "... usa pure `origin` come nome del repository remoto come sempre.*"
+            ]
+          }
+        }
+      ]
     }
   }
 };

src/levels/remote/pushArgs2.js

@@ -18,7 +18,8 @@ exports.level = {
     "uk": "Розширені аргументи git push!",
     "vi": "Tham số git push -- bản mở rộng!",
     "sl_SI": "Git push argumenti -- Razširjeni!",
-    "pl": "Argumenty git push -- Głębiej!"
+    "pl": "Argumenty git push -- Głębiej!",
+    "it_IT": "Parametri di git push - Espansione!"
   },
   "hint": {
     "en_US": "Remember you can admit defeat and type in \"show solution\" :P",
@@ -36,7 +37,8 @@ exports.level = {
     "uk": "Пам'ятай, ти завжди можеш визнати поразку і підглянути рішення командою \"show solution\" :P",
     "vi": "Nhớ rằng, bạn có thể thừa nhận thất bại và gõ \"show solution\" :P",
     "sl_SI": "Vedno se lahko predaš in napišeš \"show solution\". :P",
-    "pl": "Pamiętaj, że możesz się poddać i zobaczyć gotowe rozwiązanie, wpisując \"show solution\" :P"
+    "pl": "Pamiętaj, że możesz się poddać i zobaczyć gotowe rozwiązanie, wpisując \"show solution\" :P",
+    "it_IT": "Puoi sempre ammettere la tua sconfitta e digitare \"show solution\" :P"
   },
   "startDialog": {
     "en_US": {
@@ -1168,6 +1170,76 @@ exports.level = {
           }
         }
       ]
+    },
+    "it_IT": {
+      "childViews": [
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "## Dettagli sul parametro `<place>`",
+              "",
+              "Ricorderai dalle lezioni precedenti che quando abbiamo specificato `main` come parametro place per git push, abbiamo specificato sia la *fonte* di provenienza dei commit che la *destinazione* d'arrivo.",
+              "",
+              "Potresti star pensando -- e se volessimo che la fonte e la destinazione fossero distinte? Se volessi caricare con push dei commit dal ramo locale `foo` verso il ramo remoto `bar`?",
+              "",
+              "Sfortunatamente ciò non è possibile in git... scherzetto! Ovviamente lo possiamo fare :)... git è davvero molto flessibile (forse troppo).",
+              "",
+              "Vediamo come nella prossima slide..."
+            ]
           }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "Per specificare sia la fonte che la destinazione di `<place>`, basta unire le due tramite i due punti:",
+              "",
+              "`git push origin <source>:<destination>`",
+              "",
+              "Questo è comunemente conosciuto come colon refspec (*colon* sono i due punti). Refspec è solo un nome complicato per riferirsi ad una posizione che git può interpretare (come il ramo `foo` o anche solo `HEAD~1`).",
+              "",
+              "Potendo specificare sia fonte che destinazione in maniera indipendente, puoi sfruttare i comandi remoti in maniera molto precisa. Vediamo una demo!"
+            ]
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "Ricorda, `source` può essere una qualsiasi posizione che git può capire:"
+            ],
+            "afterMarkdowns": [
+              "Wow! Un comando bello contorto ma sensato -- git ha interpretato `foo^` come una posizione, caricato i commit che non erano presenti nel repository remoto, e poi aggiornato la destinazione."
+            ],
+            "command": "git push origin foo^:main",
+            "beforeCommand": "git clone; go -b foo; git commit; git commit"
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "E se la destinazione alla quale vuoi caricare i dati non esiste? Nessun problema! Basta specificare il nome di un ramo e git lo creerà sul remoto per te."
+            ],
+            "afterMarkdowns": [
+              "Facile così :D"
+            ],
+            "command": "git push origin main:newBranch",
+            "beforeCommand": "git clone; git commit"
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "Per questo livello, prova a raggiungere lo stato finale mostrato nella finestra obiettivo, e ricorda il formato:",
+              "",
+              "`<source>:<destination>`"
+            ]
+          }
+        }
+      ]
+    },
   }
 };

src/levels/remote/pushManyFeatures.js

@@ -18,7 +18,8 @@ exports.level = {
     "uk": "Пам'ятай, ти в будь-який момент можеш використовувати команди undo або reset",
     "vi": "Nhớ rằng bạn luôn luôn có thể hoàn tác hoặc soạn lại câu lệnh ",
     "sl_SI": "Vedno lahko razveljaviš ukaz ali ponastaviš stopnjo.",
-    "pl": "Pamiętaj, że zawsze możesz skorzystać z poleceń undo i reset"
+    "pl": "Pamiętaj, że zawsze możesz skorzystać z poleceń undo i reset",
+    "it_IT": "Ricorda che puoi sempre usare i comandi undo e reset"
   },
   "name": {
     "en_US": "Push Main!",
@@ -36,7 +37,8 @@ exports.level = {
     "uk": "Push Maйстер!",
     "vi": "Push Main!",
     "sl_SI": "Push Main!",
-    "pl": "Wypychanie dla wytrwałych!"
+    "pl": "Wypychanie dla wytrwałych!",
+    "it_IT": "Push main!"
   },
   "compareOnlyMainHashAgnostic": true,
   "startDialog": {
@@ -887,6 +889,59 @@ exports.level = {
           }
         }
       ]
+    },
+    "it_IT": {
+      "childViews": [
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "## Fondere rami di funzionalità",
+              "",
+              "Ora che ti sei ambientato con fetch, pull e push, vediamo di testare queste skill in un nuovo flusso di lavoro.",
+              "",
+              "È comune che gli sviluppatori di grandi progetti svolgano il loro lavoro su dei rami per le funzionalità (feature branch, basati sul `main`). Questo è simile alla lezione precedente (dove rami secondari vengono caricati nel remoto), ma qui aggiungiamo un ulteriore passo.",
+              "",
+              "Alcuni sviluppatori caricano e scaricano commit solo quando sono sul ramo `main` -- in questo modo `main` rimane sempre aggiornato allo stato del remoto ('`o/main`).",
+              "",
+              "Quindi per questo flusso di lavoro devi unire due cose:",
+              "",
+              "* integrare feature branch a partire dal `main`, e",
+              "* usare push e pull verso il repository remoto"
+            ]
           }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "Diamo una rinfrescata veloce su come aggiornare `main` e caricare il nostro lavoro."
+            ],
+            "afterMarkdowns": [
+              "Abbiamo eseguito due comandi:",
+              "",
+              "* abbiamo ribasato il nostro lavoro sul nuovo commit dal remoto, e",
+              "* abbiamo pubblicato il nostro lavoro sul remoto"
+            ],
+            "command": "git pull --rebase; git push",
+            "beforeCommand": "git clone; git commit; git fakeTeamwork"
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "Questo livello è abbastanza impegnativo -- ecco come risolverlo a grandi linee:",
+              "",
+              "* Ci sono tre feature branch -- `side1` `side2` e `side3`",
+              "* Vogliamo caricare ciascuna di queste funzionalità, in ordine, sul remoto",
+              "* Il remoto nel mentre è stato aggiornato, quindi dobbiamo prima incorporare quelle modifiche",
+              "",
+              "tosto :O! buona fortuna, completare questo livello è un gran passo."
+            ]
+          }
+        }
+      ]
+    },
   }
 };

src/levels/remote/remoteBranches.js

@@ -1023,7 +1023,7 @@ exports.level = {
           "type": "ModalAlert",
           "options": {
             "markdowns": [
-              "## Git Rami Remoti",
+              "## Rami remoti di Git",
               "",
               "Adesso che hai visto `git clone` in azione, tuffiamoci all'interno di quello che è effettivamente cambiato.",
               "",
@@ -1031,7 +1031,7 @@ exports.level = {
               "",
               "I rami remoti riflettono lo _stato_ dei repository remoti (dall'ultima volta che hai comunicato con quei repository remoti). Ti aiutano a capire la differenza tra il tuo lavoro locale e quello pubblico -- un passo fondamentale da fare prima di condividere il tuo lavoro con gli altri.",
               "",
-              "I rami remoti hanno la proprietà speciale che quando li controlli, `HEAD` viene inserito nella modalità di distacco. Git fa questo di proposito così che tu non possa lavorare direttamente su questi rami; ma dovrai lavorare altrove per poi condividere il tuo lavoro con  il remoto (dopodichè i tuoi rami remoti verranno aggiornati)."
+              "I rami remoti hanno la proprietà speciale che quando li controlli, `HEAD` viene inserito nella modalità di distacco. Git fa questo di proposito così che tu non possa lavorare direttamente su questi rami; ma dovrai lavorare altrove per poi condividere il tuo lavoro con il remoto (dopodiché i tuoi rami remoti verranno aggiornati)."
             ]
           }
         },
@@ -1047,7 +1047,7 @@ exports.level = {
               "",
               "Quindi, se guardi ad un ramo chiamato `o/main`, il nome del ramo è `main` e il nome del remoto è `o`.",
               "",
-              "La maggior parte degli sviluppatori in realtà nomina il loro main remoto `origin`, non `o`. Questo è così comune che git in realtà configura il remoto per essere chiamato `origin` quando si `git clone` un repository.",
+              "La maggior parte degli sviluppatori in realtà nomina il loro main remoto `origin`, non `o`. Questo è così comune che git in realtà configura il remoto per essere chiamato `origin` quando viene eseguito `git clone` su un repository.",
               "",
               "Sfortunatamente il nome completo di `origin` non si adatta alla nostra interfaccia utente, quindi usiamo `o` come abbreviazione :( Ricorda solo che quando usi git realmente, il tuo remoto probabilmente si chiamerà `origin`!",
               "",
@@ -1062,7 +1062,7 @@ exports.level = {
               "Dai un'occhiata ad un ramo remoto e vedi che cosa fa."
             ],
             "afterMarkdowns": [
-              "Come puoi vedere , git ci ha messo im modalità `HEAD` distaccata e poi non ha aggiornato `o/main` quando abbiamo aggiunto un nuovo commit. Questo perché `o/main` si aggiornerà solo quando lo farà anche il remoto."
+              "Come puoi vedere, git ci ha messo im modalità `HEAD` distaccata e poi non ha aggiornato `o/main` quando abbiamo aggiunto un nuovo commit. Questo perché `o/main` si aggiornerà solo quando lo farà anche il remoto."
             ],
             "command": "git checkout o/main; git commit",
             "beforeCommand": "git clone"
@@ -1072,7 +1072,7 @@ exports.level = {
           "type": "ModalAlert",
           "options": {
             "markdowns": [
-              "Per completare questo livello, fai un commit una volta fuori dal `main` e una volta dopo aver controllato `o/main`. Questo ti aiuterà a capire come i rami remoti si comportano differentemente, e  si aggiornano solo per riflettere lo stato del remoto"
+              "Per completare questo livello, fai un commit una volta dal `main` e una volta dopo aver aver eseguito il checkout su `o/main`. Questo ti aiuterà a capire come i rami remoti si comportano differentemente, e si aggiornano solo per riflettere lo stato del remoto"
             ]
           }
         }

src/levels/remote/sourceNothing.js

@@ -24,7 +24,8 @@ exports.level = {
     "uk": "Нема джерела",
     "vi": "Không có nguồn",
     "sl_SI": "Izvor Ničesar",
-    "pl": "Źródło nicości"
+    "pl": "Źródło nicości",
+    "it_IT": "Fonte del nulla"
   },
   "hint": {
     "en_US": "The branch command is disabled for this level so you'll have to use fetch!",
@@ -42,7 +43,8 @@ exports.level = {
     "uk": "Команда branch недоступна на цьому уроці, користуйся командою fetch!",
     "vi": "Lệnh branch đã bị vô hiệu hóa ở cấp độ này nên bạn sẽ phải dùng fetch!",
     "sl_SI": "Ukaz za branchanje je v tej stopnji onemogočen, zato boš moral uporabiti fetch!",
-    "pl": "Polecenie branch jest zablokowane na tym poziomie, musisz skorzystać z fetch!"
+    "pl": "Polecenie branch jest zablokowane na tym poziomie, musisz skorzystać z fetch!",
+    "it_IT": "Il comando branch è disabilitato per questo livello quindi dovrai usare fetch!"
   },
   "startDialog": {
     "en_US": {
@@ -896,6 +898,59 @@ exports.level = {
           }
         }
       ]
+    },
+    "it_IT": {
+      "childViews": [
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "### Stranezze di `<source>`",
+              "",
+              "Git abusa del parametro `<source>` in due strani modi. Questi due abusi derivano dal fatto che tu puoi tecnicamente specificare \"nulla\" come una fonte valida sia per git push che per git fetch. Si può fare ciò lasciando il parametro vuoto:",
+              "",
+              "* `git push origin :side`",
+              "* `git fetch origin :bugFix`",
+              "",
+              "Vediamo cosa fanno questi..."
+            ]
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "In cosa consiste il caricare \"nulla\" ad un ramo remoto? Lo elimina!"
+            ],
+            "afterMarkdowns": [
+              "Ecco, abbiamo eliminato con successo il ramo `foo` avendovi caricato il concetto di \"nulla\". Ha senso effettivamente..."
+            ],
+            "command": "git push origin :foo",
+            "beforeCommand": "git clone; git push origin main:foo"
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "Infine, scaricare il \"nulla\" in una posizione locale va a creare un nuovo ramo."
+            ],
+            "afterMarkdowns": [
+              "Molto strano, ma vabbé. Questo e altro da git!"
+            ],
+            "command": "git fetch origin :bar",
+            "beforeCommand": "git clone"
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "Questo è un livello rapido -- elimina un ramo remoto e creane uno localmente tramite `git fetch` per terminare il livello!"
+            ]
+          }
+        }
+      ]
     }
   }
 };

src/levels/remote/tracking.js

@@ -18,7 +18,8 @@ exports.level = {
     "uk": "Слідкуємо за віддаленим репозиторієм",
     "vi": "Theo dõi từ xa",
     "sl_SI": "Sledenje Oddaljenega Repota",
-    "pl": "Śledzenie zdalnych repo"
+    "pl": "Śledzenie zdalnych repo",
+    "it_IT": "Tracciamento remoto"
   },
   "hint": {
     "en_US": "Remember there are two ways to set remote tracking!",
@@ -36,7 +37,8 @@ exports.level = {
     "uk": "Пам'ятай, є два способи слідкувати за віддаленим репозиорієм!",
     "vi": "Hãy nhớ rằng, có 2 cách để thiết lập theo dõi từ xa!",
     "sl_SI": "Spomni se, da obstajata dva načina za sledenje oddaljenega repota.",
-    "pl": "Pamiętaj, zdalne repo można śledzić na dwa sposoby!"
+    "pl": "Pamiętaj, zdalne repo można śledzić na dwa sposoby!",
+    "it_IT": "Ricorda che ci sono due modi per impostare il tracciamento remoto!"
   },
   "startDialog": {
     "en_US": {
@@ -2047,6 +2049,124 @@ exports.level = {
           }
         }
       ]
+    },
+    "it_IT": {
+      "childViews": [
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "### Rami che tracciano il remoto",
+              "",
+              "Una cosa che può esser sembrata \"magica\" riguardo le ultime lezioni è come git sapesse che il ramo `main` fosse connesso a `o/main`. Certo questi rami hanno dei nomi simili e avrebbe senso collegare il ramo `main` sul repository remoto al ramo `main` locale, ma questa connessione è chiaramente dimostrata in due scenari:",
+              "",
+              "* Durante un'operazione di pull, i commit sono scaricati su `o/main` e poi *fusi* al ramo `main`. Il destinatario del merge è determinato da questa connessione.",
+              "* Durante un'operazione di push, il lavoro proveniente dal ramo `main` è stato caricato sul ramo `main` remoto (rappresentato localmente da `o/main`). La *destinazione* del push è determinata dalla connessione tra `main` e `o/main`.",
+              ""
+            ]
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "## Tracciamento remoto",
+              "",
+              "Per farla breve, questa connessione tra `main` e `o/main` viene spiegata facilmente dalla proprietà di \"tracciamento remoto\" dei rami. Il ramo `main` è impostato per tracciare `o/main` -- questo significa che sono presenti un destinatario implicito della fusione e una destinazione implicita del push per il ramo `main`.",
+              "",
+              "Potresti chiederti come questa proprietà è stata impostata sul ramo `main` quando tu non hai eseguito alcun comando per specificarlo. Quando cloni un repository con git, questa proprietà viene impostata automaticamente.",
+              "",
+              "Durante un clone, git crea un ramo remoto per ciascun ramo presente sul repository remoto (aka rami come `o/main`). Crea poi un ramo locale che traccia il ramo attivo al momento sul remoto, che risulta essere `main` nella maggior parte dei casi.",
+              "",
+              "Una volta terminato git clone, di questi rimane solo un ramo locale (per non sovraccaricarti) ma puoi vedere tutti i vari rami presenti sul remoto (in caso tu fossi curioso). È come prendere due piccioni con una fava!",
+              "",
+              "Questo spiega inoltre perché potresti ricevere questo output durante la clonazione:",
+              "",
+              "    local branch \"main\" set to track remote branch \"o/main\""
+            ]
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "### Posso specificarlo io?",
+              "",
+              "Sì che puoi! Puoi decidere arbitrariamente di far tracciare a qualsiasi ramo `o/main`, e se lo fai, quel ramo avrà le stesse destinazioni implicite per push e merge di `main`. Ciò significa che puoi eseguire `git push` su un ramo chiamato `perNienteIlMain` e vedere il tuo lavoro caricato sul ramo `main` nel repository remoto!",
+              "",
+              "Ci sono due modi per impostare questa proprietà. Il primo è creare il nuovo ramo tramite checkout specificando un ramo remoto come riferimento. Eseguire",
+              "",
+              "`git checkout -b perNienteIlMain o/main`",
+              "",
+              "Crea un nuovo ramo chiamato `perNienteIlMain` e lo imposta a tracciare `o/main`."
+            ]
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "Abbiamo parlato abbastanza, vediamo una dimostrazione! Creeremo tramite checkout un nuovo ramo chiamato `foo` e verrà impostato a tracciare `main` sul remoto."
+            ],
+            "afterMarkdowns": [
+              "Come puoi vedere, abbiamo usato il destinatario implicito di `o/main` per aggiornare il ramo `foo`. Se vedi il main non è stato aggiornato!!"
+            ],
+            "command": "git checkout -b foo o/main; git pull",
+            "beforeCommand": "git clone; git fakeTeamwork"
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "Lo stesso vale per git push."
+            ],
+            "afterMarkdowns": [
+              "Boom. Abbiamo caricato il nostro lavoro al ramo `main` sul repository remoto nonostante il nostro ramo avesse un nome totalmente diverso."
+            ],
+            "command": "git checkout -b foo o/main; git commit; git push",
+            "beforeCommand": "git clone"
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "### Way #2",
+              "",
+              "Un altro modo per impostare il tracciamento remoto su un ramo è tramite l'opzione `git branch -u`. Eseguire",
+              "",
+              "`git branch -u o/main foo`",
+              "",
+              "imposterà il ramo `foo` a tracciare `o/main`. Se stiamo attualmente lavorando su `foo` possiamo ometterlo:",
+              "",
+              "`git branch -u o/main`",
+              ""
+            ]
+          }
+        },
+        {
+          "type": "GitDemonstrationView",
+          "options": {
+            "beforeMarkdowns": [
+              "Vediamo al volo quest'altro metodo per specificare il tracciamento remoto..."
+            ],
+            "afterMarkdowns": [
+              "Come prima, solo tramite un comando più esplicito. Bene dai!"
+            ],
+            "command": "git branch -u o/main foo; git commit; git push",
+            "beforeCommand": "git clone; git checkout -b foo"
+          }
+        },
+        {
+          "type": "ModalAlert",
+          "options": {
+            "markdowns": [
+              "Ok! Per qusto livello carica del lavoro sul ramo `main` del remoto mentre *non* sei attualmente sul ramo `main` locale. Al resto devi arrivarci tu, d'altronde questo è il corso avanzato :P"
+            ]
+          }
+        }
+      ]
     }
   }
 };