Anonymous avatar Anonymous committed eed01b9

Typography.

Comments (0)

Files changed (21)

   <sect1>
     <title>Importare la cronologia da un altro sistema</title>
 
-    <para id="x_6e3">Mercurial include un'estensione chiamata <literal>convert</literal> che può importare la cronologia di un progetto dalla maggior parte dei sistemi di controllo di revisione più popolari. Al momento in cui il libro è stato scritto, l'estensione può importare la cronologia dai seguenti sistemi:</para>
+    <para id="x_6e3">Mercurial include un&rsquo;estensione chiamata <literal>convert</literal> che può importare la cronologia di un progetto dalla maggior parte dei sistemi di controllo di revisione più popolari. Al momento in cui il libro è stato scritto, l&rsquo;estensione può importare la cronologia dai seguenti sistemi:</para>
     <itemizedlist>
       <listitem>
 	<para id="x_6e4">Subversion</para>
 
     <para id="x_6ec">(Per verificare perché lo stesso Mercurial sia supportato come sorgente da cui importare la cronologia, si veda la <xref linkend="svn.filemap"/>.)</para>
 
-    <para id="x_6ed">Potete attivare l'estensione nel solito modo, modificando il vostro file <filename>~/.hgrc</filename>.</para>
+    <para id="x_6ed">Potete attivare l&rsquo;estensione nel solito modo, modificando il vostro file <filename>~/.hgrc</filename>.</para>
 
     <programlisting>[extensions]
 convert =</programlisting>
 
-    <para id="x_6ee">Questo renderà disponibile il comando <command>hg convert</command>. Il comando è facile da usare. Per esempio, l'invocazione seguente importerà in Mercurial la cronologia di Subversion per Nose, un framework per il collaudo di unità.</para>
+    <para id="x_6ee">Questo renderà disponibile il comando <command>hg convert</command>. Il comando è facile da usare. Per esempio, l&rsquo;invocazione seguente importerà in Mercurial la cronologia di Subversion per Nose, un framework per il collaudo di unità.</para>
 
     <screen><prompt>$</prompt> <userinput>hg convert http://python-nose.googlecode.com/svn/trunk</userinput></screen>
 
-    <para id="x_6ef">L'estensione <literal>convert</literal> opera in maniera incrementale. In altre parole, dopo che avete invocato <command>hg convert</command> una prima volta, invocandolo nuovamente importerete tutte le nuove revisioni che sono state inserite dopo la vostra prima esecuzione del comando. La conversione incrementale funzionerà solo se invocate <command>hg convert</command> nello stesso repository Mercurial che avete usato in origine, perché l'estensione <literal>convert</literal> salva alcuni metadati privati all'interno del repository in un file chiamato <filename>.hg/shamap</filename> non soggetto al controllo di revisione.</para>
+    <para id="x_6ef">L&rsquo;estensione <literal>convert</literal> opera in maniera incrementale. In altre parole, dopo che avete invocato <command>hg convert</command> una prima volta, invocandolo nuovamente importerete tutte le nuove revisioni che sono state inserite dopo la vostra prima esecuzione del comando. La conversione incrementale funzionerà solo se invocate <command>hg convert</command> nello stesso repository Mercurial che avete usato in origine, perché l&rsquo;estensione <literal>convert</literal> salva alcuni metadati privati all&rsquo;interno del repository in un file chiamato <filename>.hg/shamap</filename> non soggetto al controllo di revisione.</para>
 
-    <para id="x_707">Quando volete cominciare a effettuare modifiche usando Mercurial, è preferibile clonare l'albero in cui state facendo le vostre conversioni e tenere da parte l'albero originale per dedicarlo a future conversioni incrementali. Questo è il modo più sicuro per estrarre i futuri commit dal sistema di controllo di revisione sorgente e incorporarli nel progetto Mercurial che avete appena creato.</para>
+    <para id="x_707">Quando volete cominciare a effettuare modifiche usando Mercurial, è preferibile clonare l&rsquo;albero in cui state facendo le vostre conversioni e tenere da parte l&rsquo;albero originale per dedicarlo a future conversioni incrementali. Questo è il modo più sicuro per estrarre i futuri commit dal sistema di controllo di revisione sorgente e incorporarli nel progetto Mercurial che avete appena creato.</para>
 
     <sect2>
       <title>Convertire molti rami</title>
 
-      <para id="x_708">Il comando <command>hg convert</command> eseguito in precedenza converte solo la cronologia del <literal>trunk</literal> del repository Subversion. Se invece usiamo l'URL <literal>http://python-nose.googlecode.com/svn</literal>, Mercurial individuerà automaticamente le directory <literal>trunk</literal>, <literal>tags</literal> e <literal>branches</literal> che compongono la struttura usata di solito dai progetti Subversion e le importerà come rami separati.</para>
+      <para id="x_708">Il comando <command>hg convert</command> eseguito in precedenza converte solo la cronologia del <literal>trunk</literal> del repository Subversion. Se invece usiamo l&rsquo;URL <literal>http://python-nose.googlecode.com/svn</literal>, Mercurial individuerà automaticamente le directory <literal>trunk</literal>, <literal>tags</literal> e <literal>branches</literal> che compongono la struttura usata di solito dai progetti Subversion e le importerà come rami separati.</para>
 
-      <para id="x_709">Per default, a ogni ramo Subversion importato in Mercurial viene assegnato un nome. Dopo che la conversione si è conclusa, potete ottenere una lista dei nomi dei rami attivi nel repository Mercurial usando <command>hg branches -a</command>. Se preferite importare i rami Subversion senza nomi, passate l'opzione <option>--config convert.hg.usebranchnames=false</option> al comando <command>hg convert</command>.</para>
+      <para id="x_709">Per default, a ogni ramo Subversion importato in Mercurial viene assegnato un nome. Dopo che la conversione si è conclusa, potete ottenere una lista dei nomi dei rami attivi nel repository Mercurial usando <command>hg branches -a</command>. Se preferite importare i rami Subversion senza nomi, passate l&rsquo;opzione <option>--config convert.hg.usebranchnames=false</option> al comando <command>hg convert</command>.</para>
 
       <para id="x_70a">Una volta che avete convertito il vostro albero, se volete seguire la consuetudine tipica per Mercurial di lavorare in un albero che contiene un singolo ramo, potete clonare quel singolo ramo usando <command>hg clone -r nomedelramo</command>.</para>
     </sect2>
     <sect2>
       <title>Correlare i nomi utente</title>
 
-      <para id="x_6f0">Alcuni strumenti di controllo di revisione salvano con ogni inserimento solo nomi utenti brevi che possono essere difficili da interpretare. Con Mercurial, la norma è quella di salvare il nome e l'indirizzo email di chi effettua il commit, due informazioni molto più utili se in seguito volessimo contattare quella persona.</para>
+      <para id="x_6f0">Alcuni strumenti di controllo di revisione salvano con ogni inserimento solo nomi utenti brevi che possono essere difficili da interpretare. Con Mercurial, la norma è quella di salvare il nome e l&rsquo;indirizzo email di chi effettua il commit, due informazioni molto più utili se in seguito volessimo contattare quella persona.</para>
 
-      <para id="x_6f1">Se state convertendo un albero da un sistema di controllo di revisione che usa nomi brevi, potete correlare quei nomi a equivalenti più lunghi passando l'opzione <option>--authors</option> al comando <command>hg convert</command>. Questa opzione accetta un nome di file che dovrebbe contenere voci nel seguente formato.</para>
+      <para id="x_6f1">Se state convertendo un albero da un sistema di controllo di revisione che usa nomi brevi, potete correlare quei nomi a equivalenti più lunghi passando l&rsquo;opzione <option>--authors</option> al comando <command>hg convert</command>. Questa opzione accetta un nome di file che dovrebbe contenere voci nel seguente formato.</para>
 
       <programlisting>arist = Aristotele &lt;aristotele@filo.example.gr&gt;
 soc = Socrate &lt;socrate@filo.example.gr&gt;</programlisting>
     </sect2>
 
     <sect2 id="svn.filemap">
-      <title>Riordinare l'albero</title>
+      <title>Riordinare l&rsquo;albero</title>
 
-      <para id="x_6f3">Non tutti i progetti hanno una cronologia pulita. Potrebbe esserci una directory che non avrebbe mai dovuto essere inserita, un file che è troppo grande, o un'intera gerarchia che ha bisogno di essere riorganizzata.</para>
+      <para id="x_6f3">Non tutti i progetti hanno una cronologia pulita. Potrebbe esserci una directory che non avrebbe mai dovuto essere inserita, un file che è troppo grande, o un&rsquo;intera gerarchia che ha bisogno di essere riorganizzata.</para>
 
-      <para id="x_6f4">L'estensione <literal>convert</literal> supporta l'idea di una <quote>mappa di file</quote> che può essere impiegata per riorganizzare i file e le directory di un progetto nel momento in cui se ne importa la cronologia. Questo è utile non solo quando si importa la cronologia da altri sistemi di controllo di revisione, ma anche per potare o riorganizzare un albero Mercurial.</para>
+      <para id="x_6f4">L&rsquo;estensione <literal>convert</literal> supporta l&rsquo;idea di una <quote>mappa di file</quote> che può essere impiegata per riorganizzare i file e le directory di un progetto nel momento in cui se ne importa la cronologia. Questo è utile non solo quando si importa la cronologia da altri sistemi di controllo di revisione, ma anche per potare o riorganizzare un albero Mercurial.</para>
 
-      <para id="x_6f5">Per specificare una mappa di file, usate l'opzione <option>--filemap</option> e fornitele un nome di file. Una mappa di file contiene righe nei seguenti formati.</para>
+      <para id="x_6f5">Per specificare una mappa di file, usate l&rsquo;opzione <option>--filemap</option> e fornitele un nome di file. Una mappa di file contiene righe nei seguenti formati.</para>
 
       <programlisting># Questo è un commento
 # Le righe vuote vengono ignorate
 rename da/qualche/percorso a/qualche/altra/posizione
 </programlisting>
 
-      <para id="x_6f6">La direttiva <literal>include</literal> provoca l'inclusione di un file, o di tutti i file contenuti in una directory, nel repository destinazione. Questa direttiva provoca anche l'esclusione di tutti gli altri file o directory che non sono state esplicitamente incluse. La direttiva <literal>exclude</literal> provoca l'esclusione dei file e delle directory indicate e di tutti quegli altri percorsi che non sono stati esplicitamente menzionati per essere inclusi.</para>
+      <para id="x_6f6">La direttiva <literal>include</literal> provoca l&rsquo;inclusione di un file, o di tutti i file contenuti in una directory, nel repository destinazione. Questa direttiva provoca anche l&rsquo;esclusione di tutti gli altri file o directory che non sono state esplicitamente incluse. La direttiva <literal>exclude</literal> provoca l&rsquo;esclusione dei file e delle directory indicate e di tutti quegli altri percorsi che non sono stati esplicitamente menzionati per essere inclusi.</para>
 
-      <para id="x_6f7">Per spostare un file o una directory da una posizione a un'altra, usate la direttiva <literal>rename</literal>. Se dovete spostare un file o una directory da una sottodirectory alla radice del repository, usate <literal>.</literal> come secondo argomento della direttiva <literal>rename</literal>.</para>
+      <para id="x_6f7">Per spostare un file o una directory da una posizione a un&rsquo;altra, usate la direttiva <literal>rename</literal>. Se dovete spostare un file o una directory da una sottodirectory alla radice del repository, usate <literal>.</literal> come secondo argomento della direttiva <literal>rename</literal>.</para>
     </sect2>
 
     <sect2>
 
       <para id="x_70b">Avrete spesso bisogno di fare diversi tentativi prima di trovare la combinazione perfetta tra mappa di utenti, mappa di file e altri parametri di conversione. La conversione di un repository Subversion attraverso un protocollo di accesso come ssh o HTTP può procedere migliaia di volte più lentamente di quanto Mercurial sia capace di operare in realtà, a causa della latenza di rete. Questo può rendere molto complicata la messa a punto di quella ricetta per la conversione perfetta.</para>
 
-      <para id="x_70c">Il comando <ulink url="http://svn.collab.net/repos/svn/trunk/notes/svnsync.txt"><command>svnsync</command></ulink> può velocizzare notevolmente la conversione di un repository Subversion. Serve per creare un mirror di sola lettura di un repository Subversion. L'idea è quella di creare un mirror locale del vostro albero Subversion per poi convertire il mirror in un repository Mercurial.</para>
+      <para id="x_70c">Il comando <ulink url="http://svn.collab.net/repos/svn/trunk/notes/svnsync.txt"><command>svnsync</command></ulink> può velocizzare notevolmente la conversione di un repository Subversion. Serve per creare un mirror di sola lettura di un repository Subversion. L&rsquo;idea è quella di creare un mirror locale del vostro albero Subversion per poi convertire il mirror in un repository Mercurial.</para>
 
       <para id="x_70d">Immaginiamo di voler convertire il repository Subversion che contiene il popolare progetto Memcached in un albero Mercurial. Per prima cosa, creiamo un repository Subversion locale.</para>
 
       <screen><prompt>$</prompt> <userinput>svnsync --init file://`pwd`/memcached-mirror \
   http://code.sixapart.com/svn/memcached</userinput></screen>
 
-      <para id="x_710">Il passo successivo consiste nell'avviare il processo di creazione del mirror con il comando <command>svnsync</command>.</para>
+      <para id="x_710">Il passo successivo consiste nell&rsquo;avviare il processo di creazione del mirror con il comando <command>svnsync</command>.</para>
 
       <screen><prompt>$</prompt> <userinput>svnsync sync file://`pwd`/memcached-mirror</userinput></screen>
 
       
       <para id="x_712">Se il repository Subversion è ancora attivo, possiamo usare questo processo in maniera incrementale. Invochiamo <command>svnsync</command> per propagare i nuovi cambiamenti verso il nostro mirror e poi invochiamo <command>hg convert</command> per importarli nel nostro albero Mercurial.</para>
 
-      <para id="x_713">Un'importazione in due stadi realizzata con <command>svnsync</command> ha due vantaggi. Il primo è che <command>svnsync</command> usa una sincronizzazione di rete con Subversion più efficiente rispetto al comando <command>hg convert</command>, quindi trasferisce meno dati attraverso la rete. Il secondo è che l'importazione da un albero Subversion locale è così veloce che potete aggiustare ripetutamente le vostre impostazioni di conversione senza aspettare ogni volta la terminazione di un processo di conversione basato su rete e dolorosamente lento.</para>
+      <para id="x_713">Un&rsquo;importazione in due stadi realizzata con <command>svnsync</command> ha due vantaggi. Il primo è che <command>svnsync</command> usa una sincronizzazione di rete con Subversion più efficiente rispetto al comando <command>hg convert</command>, quindi trasferisce meno dati attraverso la rete. Il secondo è che l&rsquo;importazione da un albero Subversion locale è così veloce che potete aggiustare ripetutamente le vostre impostazioni di conversione senza aspettare ogni volta la terminazione di un processo di conversione basato su rete e dolorosamente lento.</para>
     </sect2>
   </sect1>
 
     <sect2>
       <title>Differenze filosofiche</title>
 
-      <para id="x_6f9">Naturalmente, la differenza fondamentale tra Subversion e Mercurial è che Subversion è centralizzato mentre Mercurial è distribuito. Dato che Mercurial memorizza tutta la cronologia di un progetto sul vostro disco locale, ha bisogno di accedere alla rete solo quando volete esplicitamente comunicare con un altro repository. Al contrario, Subversion memorizza localmente un'esigua quantità di informazioni, perciò il client deve contattare il proprio server per molte operazioni comuni.</para>
+      <para id="x_6f9">Naturalmente, la differenza fondamentale tra Subversion e Mercurial è che Subversion è centralizzato mentre Mercurial è distribuito. Dato che Mercurial memorizza tutta la cronologia di un progetto sul vostro disco locale, ha bisogno di accedere alla rete solo quando volete esplicitamente comunicare con un altro repository. Al contrario, Subversion memorizza localmente un&rsquo;esigua quantità di informazioni, perciò il client deve contattare il proprio server per molte operazioni comuni.</para>
 
-      <para id="x_6fa">Subversion riesce più o meno a cavarsela senza una nozione di ramo ben definita: qualificare come ramo una porzione dello spazio di nomi sul server è una questione di convenzioni, e il software non impone alcuna costrizione. Mercurial tratta un repository come l'unità della gestione dei rami.</para>
+      <para id="x_6fa">Subversion riesce più o meno a cavarsela senza una nozione di ramo ben definita: qualificare come ramo una porzione dello spazio di nomi sul server è una questione di convenzioni, e il software non impone alcuna costrizione. Mercurial tratta un repository come l&rsquo;unità della gestione dei rami.</para>
 
       <sect3>
-	<title>L'ambito dei comandi</title>
+	<title>L&rsquo;ambito dei comandi</title>
 
-	<para id="x_6fb">Dato che Subversion non sa quali parti del suo spazio di nomi siano realmente rami, tratta la maggior parte dei comandi come se richiedesse di operare al livello della directory in cui vi trovate e ai livelli sottostanti. Per esempio, se eseguite <command>svn log</command>, otterrete la cronologia di qualunque parte dell'albero stiate osservando, non dell'intero albero.</para>
+	<para id="x_6fb">Dato che Subversion non sa quali parti del suo spazio di nomi siano realmente rami, tratta la maggior parte dei comandi come se richiedesse di operare al livello della directory in cui vi trovate e ai livelli sottostanti. Per esempio, se eseguite <command>svn log</command>, otterrete la cronologia di qualunque parte dell&rsquo;albero stiate osservando, non dell&rsquo;intero albero.</para>
 
-	<para id="x_6fc">Il comportamento predefinito di Mercurial è differente perché i suoi comandi operano sull'intero repository. Eseguite <command>hg log</command> e vi mostrerà la cronologia dell'intero albero, a prescindere da quale parte della directory di lavoro stiate visitando in quel momento. Se volete solo la cronologia di un file o di una directory particolare, vi basta fornire un nome al comando, e.g. <command>hg log sorgenti</command>.</para>
+	<para id="x_6fc">Il comportamento predefinito di Mercurial è differente perché i suoi comandi operano sull&rsquo;intero repository. Eseguite <command>hg log</command> e vi mostrerà la cronologia dell&rsquo;intero albero, a prescindere da quale parte della directory di lavoro stiate visitando in quel momento. Se volete solo la cronologia di un file o di una directory particolare, vi basta fornire un nome al comando, e.g. <command>hg log sorgenti</command>.</para>
 
 	<para id="x_6fd">Secondo la mia esperienza, questa differenza nel comportamento predefinito dei comandi è probabilmente la cosa che può confondervi di più se dovete spostarvi frequentemente avanti e indietro tra i due strumenti.</para>
       </sect3>
 
 	<para id="x_6fe">Con Subversion, è normale (anche se blandamente deprecato) che più persone collaborino su un singolo ramo. Se Alice e Bruno stanno lavorando insieme e Alice inserisce alcune modifiche nel ramo condiviso, Bruno deve aggiornare la vista del ramo del suo client prima di poter effettuare un commit. Dato che in quel momento non esiste alcuna registrazione permanente dei cambiamenti fatti da Bruno, le sue modifiche potrebbero rovinarsi o andare perdute durante e dopo questo aggiornamento.</para>
 
-	<para id="x_6ff">Mercurial, invece, incoraggia un modello di inserimento-e-unione. Bruno inserisce le sue modifiche nella sua copia locale del repository prima di estrarre o trasmettere i cambiamenti da o verso il server che condivide con Alice. Se Alice trasmette i suoi cambiamenti prima che Bruno provi a trasmettere i propri, Bruno non sarà in grado di trasmettere i suoi cambiamenti prima di aver estratto quelli di Alice, averli incorporati e aver effettuato il commit dei risultati dell'unione. Se Bruno commette un errore durante l'unione, può sempre ritornare al commit con il quale aveva registrato i suoi cambiamenti.</para>
+	<para id="x_6ff">Mercurial, invece, incoraggia un modello di inserimento-e-unione. Bruno inserisce le sue modifiche nella sua copia locale del repository prima di estrarre o trasmettere i cambiamenti da o verso il server che condivide con Alice. Se Alice trasmette i suoi cambiamenti prima che Bruno provi a trasmettere i propri, Bruno non sarà in grado di trasmettere i suoi cambiamenti prima di aver estratto quelli di Alice, averli incorporati e aver effettuato il commit dei risultati dell&rsquo;unione. Se Bruno commette un errore durante l&rsquo;unione, può sempre ritornare al commit con il quale aveva registrato i suoi cambiamenti.</para>
 
 	<para id="x_700">Vale la pena sottolineare che questi sono i modi più comuni di lavorare con questi strumenti. Subversion supporta un modello più sicuro per consentirvi di lavorare nel vostro ramo personale, che però in pratica si rivela abbastanza scomodo da non essere particolarmente diffuso. Mercurial può supportare un modello meno sicuro che permette di estrarre e unire i cambiamenti nonostante la presenza di modifiche non ancora registrate, ma questo è considerato estremamente inusuale.</para>
       </sect3>
 
 	<para id="x_702">Con Mercurial, i commit sono sempre locali e devono essere pubblicati successivamente tramite il comando <command>hg push</command>.</para>
 
-	<para id="x_703">Ogni approccio ha i propri vantaggi e svantaggi. Il modello di Subversion prevede che i cambiamenti siano pubblicati, e quindi revisionabili e utilizzabili, immediatamente. D'altra parte, questo significa che un utente deve avere accesso in scrittura a un repository per utilizzare normalmente lo strumento, ma la maggior parte dei progetti open source non concede i permessi di scrittura alla leggera.</para>
+	<para id="x_703">Ogni approccio ha i propri vantaggi e svantaggi. Il modello di Subversion prevede che i cambiamenti siano pubblicati, e quindi revisionabili e utilizzabili, immediatamente. D&rsquo;altra parte, questo significa che un utente deve avere accesso in scrittura a un repository per utilizzare normalmente lo strumento, ma la maggior parte dei progetti open source non concede i permessi di scrittura alla leggera.</para>
 
-	<para id="x_704">L'approccio di Mercurial consente a chiunque possa clonare un repository di inserirvi modifiche senza il bisogno del permesso di qualcun altro e di pubblicare i propri cambiamenti e continuare a partecipare nel modo che preferisce. A causa della distinzione tra le operazioni di inserimento e trasmissione dei cambiamenti, può capitare che qualcuno effettui il commit di alcune modifiche sul proprio computer e si allontani per qualche giorno dimenticandosi di trasmetterli, cosa che in rari casi potrebbe bloccare temporaneamente le attività dei collaboratori.</para>
+	<para id="x_704">L&rsquo;approccio di Mercurial consente a chiunque possa clonare un repository di inserirvi modifiche senza il bisogno del permesso di qualcun altro e di pubblicare i propri cambiamenti e continuare a partecipare nel modo che preferisce. A causa della distinzione tra le operazioni di inserimento e trasmissione dei cambiamenti, può capitare che qualcuno effettui il commit di alcune modifiche sul proprio computer e si allontani per qualche giorno dimenticandosi di trasmetterli, cosa che in rari casi potrebbe bloccare temporaneamente le attività dei collaboratori.</para>
       </sect3>
     </sect2>
 
 	      <entry><command>svn info</command></entry>
 	      <entry><command>hg showconfig
 		  paths.parent</command></entry>
-	      <entry>Mostra da quale URL è avvenuta l'estrazione</entry>
+	      <entry>Mostra da quale URL è avvenuta l&rsquo;estrazione</entry>
 	    </row>
 	    <row>
 	      <entry><command>svn list</command></entry>
   <sect1>
     <title>Suggerimenti utili per i principianti</title>
 
-    <para id="x_705">In alcuni sistemi di controllo di revisione, può diventare complicato stampare le differenze per una singola revisione registrata nel repository. Per esempio, con Subversion, per vedere cos'è cambiato nella revisione 104654 dovete digitare <command>svn diff -r104653:104654</command>. Mercurial elimina la necessità di digitare due volte l'identificatore di revisione in questo caso comune. Per ottenere solo le differenze, digitate <command>hg export 104654</command>. Per ottenere un messaggio dal registro della cronologia seguito dalle differenze, digitate <command>hg log -r104654 -p</command>.</para>
+    <para id="x_705">In alcuni sistemi di controllo di revisione, può diventare complicato stampare le differenze per una singola revisione registrata nel repository. Per esempio, con Subversion, per vedere cos&rsquo;è cambiato nella revisione 104654 dovete digitare <command>svn diff -r104653:104654</command>. Mercurial elimina la necessità di digitare due volte l&rsquo;identificatore di revisione in questo caso comune. Per ottenere solo le differenze, digitate <command>hg export 104654</command>. Per ottenere un messaggio dal registro della cronologia seguito dalle differenze, digitate <command>hg log -r104654 -p</command>.</para>
 
-    <para id="x_706">Quando eseguite <command>hg status</command> senza argomenti, vi viene mostrato lo stato dell'intero albero, con i percorsi relativi alla radice del repository. Questo rende complicato copiare un nome di file dal risultato di <command>hg status</command> alla riga di comando. Se eseguite <command>hg status</command> passandogli il nome di un file o di una directory, il comando stamperà i percorsi relativi alla vostra posizione corrente. Quindi, per ottenere da <command>hg status</command> lo stato di tutto l'albero, con i percorsi relativi alla vostra directory corrente invece che alla radice del repository, passate il risultato di <command>hg root</command> al comando <command>hg status</command>. Su un sistema di tipo Unix, potete farlo facilmente nel modo che segue:</para>
+    <para id="x_706">Quando eseguite <command>hg status</command> senza argomenti, vi viene mostrato lo stato dell&rsquo;intero albero, con i percorsi relativi alla radice del repository. Questo rende complicato copiare un nome di file dal risultato di <command>hg status</command> alla riga di comando. Se eseguite <command>hg status</command> passandogli il nome di un file o di una directory, il comando stamperà i percorsi relativi alla vostra posizione corrente. Quindi, per ottenere da <command>hg status</command> lo stato di tutto l&rsquo;albero, con i percorsi relativi alla vostra directory corrente invece che alla radice del repository, passate il risultato di <command>hg root</command> al comando <command>hg status</command>. Su un sistema di tipo Unix, potete farlo facilmente nel modo che segue:</para>
 
     <screen><prompt>$</prompt> <userinput>hg status `hg root`</userinput></screen>
   </sect1>

it/appB-mq-ref.xml

   <sect1 id="sec:mqref:cmdref">
     <title>Guida di riferimento ai comandi MQ</title>
 
-    <para id="x_5e8">Per un'introduzione ai comandi forniti da MQ, usate il comando <command role="hg-cmd">hg help mq</command>.</para>
+    <para id="x_5e8">Per un&rsquo;introduzione ai comandi forniti da MQ, usate il comando <command role="hg-cmd">hg help mq</command>.</para>
 
     <sect2>
       <title><command role="hg-ext-mq">qapplied</command>&emdash;stampa le patch applicate</title>
 
-      <para id="x_5e9">Il comando <command role="hg-ext-mq">qapplied</command> stampa la pila corrente delle patch applicate. Le patch vengono stampate in ordine dalla più vecchia alla più recente, così l'ultima patch nella lista è quella <quote>in cima</quote> alla pila.</para>
+      <para id="x_5e9">Il comando <command role="hg-ext-mq">qapplied</command> stampa la pila corrente delle patch applicate. Le patch vengono stampate in ordine dalla più vecchia alla più recente, così l&rsquo;ultima patch nella lista è quella <quote>in cima</quote> alla pila.</para>
 
     </sect2>
     <sect2>
 
       <para id="x_5ea">Il comando <command role="hg-ext-mq">qcommit</command> registra qualsiasi cambiamento in sospeso nel repository <filename role="special" class="directory">.hg/patches</filename>. Questo comando funziona solo se la directory <filename role="special" class="directory">.hg/patches</filename> è un repository, cioè se avete creato la directory usando <command role="hg-cmd">hg qinit <option role="hg-ext-mq-cmd-qinit-opt">-c</option></command> o avete invocato <command role="hg-cmd">hg init</command> nella directory dopo aver eseguito <command role="hg-ext-mq">qinit</command>.</para>
 
-      <para id="x_5eb">Questo comando è un'abbreviazione di <command role="hg-cmd">hg commit --cwd .hg/patches</command>.</para>
+      <para id="x_5eb">Questo comando è un&rsquo;abbreviazione di <command role="hg-cmd">hg commit --cwd .hg/patches</command>.</para>
     </sect2>
     <sect2>
 	<title><command role="hg-ext-mq">qdelete</command>&emdash;elimina una patch dal file <filename role="special">series</filename></title>
 
-      <para id="x_5ec">Il comando <command role="hg-ext-mq">qdelete</command> rimuove la voce relativa a una patch dal file <filename role="special">series</filename> nella directory <filename role="special" class="directory">.hg/patches</filename>. Non estrae la patch se la patch è già applicata. Per default, non cancella il file della patch, perciò dovrete usare l'opzione <option role="hg-ext-mq-cmd-qdel-opt">-f</option> se volete fare questo.</para>
+      <para id="x_5ec">Il comando <command role="hg-ext-mq">qdelete</command> rimuove la voce relativa a una patch dal file <filename role="special">series</filename> nella directory <filename role="special" class="directory">.hg/patches</filename>. Non estrae la patch se la patch è già applicata. Per default, non cancella il file della patch, perciò dovrete usare l&rsquo;opzione <option role="hg-ext-mq-cmd-qdel-opt">-f</option> se volete fare questo.</para>
 
       <para id="x_5ed">Opzioni:</para>
       <itemizedlist>
 
     </sect2>
     <sect2>
-      <title><command role="hg-ext-mq">qdiff</command>&emdash;stampa un diff dell'ultima patch applicata</title>
+      <title><command role="hg-ext-mq">qdiff</command>&emdash;stampa un diff dell&rsquo;ultima patch applicata</title>
 
-      <para id="x_5ef">Il comando <command role="hg-ext-mq">qdiff</command> stampa un diff dell'ultima patch applicata. &Egrave; equivalente al comando <command role="hg-cmd">hg diff -r-2:-1</command>.</para>
+      <para id="x_5ef">Il comando <command role="hg-ext-mq">qdiff</command> stampa un diff dell&rsquo;ultima patch applicata. &Egrave; equivalente al comando <command role="hg-cmd">hg diff -r-2:-1</command>.</para>
 
     </sect2>
     <sect2>
     <sect2>
       <title><command role="hg-ext-mq">qfold</command>&emdash;unisce (<quote>include</quote>) diverse patch in una</title>
 
-      <para id="x_5f0">Il comando <command role="hg-ext-mq">qfold</command> unisce più patch all'ultima patch applicata, in modo che l'ultima patch applicata rappresenti l'unione di tutti i cambiamenti delle patch in questione.</para>
+      <para id="x_5f0">Il comando <command role="hg-ext-mq">qfold</command> unisce più patch all&rsquo;ultima patch applicata, in modo che l&rsquo;ultima patch applicata rappresenti l&rsquo;unione di tutti i cambiamenti delle patch in questione.</para>
 
-      <para id="x_5f1">Le patch da includere non devono essere applicate, altrimenti <command role="hg-ext-mq">qfold</command> terminerà segnalando un errore. L'ordine in cui le patch vengono incluse è significativo: <command role="hg-cmd">hg qfold a b</command> significa <quote>applica la patch più recente, seguita da <literal>a</literal>, seguita da <literal>b</literal></quote>.</para>
+      <para id="x_5f1">Le patch da includere non devono essere applicate, altrimenti <command role="hg-ext-mq">qfold</command> terminerà segnalando un errore. L&rsquo;ordine in cui le patch vengono incluse è significativo: <command role="hg-cmd">hg qfold a b</command> significa <quote>applica la patch più recente, seguita da <literal>a</literal>, seguita da <literal>b</literal></quote>.</para>
 
-      <para id="x_5f2">I commenti delle patch incluse vengono aggiunti alla fine dei commenti della patch di destinazione, separando ogni blocco di commenti con tre caratteri di asterisco (<quote><literal>*</literal></quote>). Usate l'opzione <option role="hg-ext-mq-cmd-qfold-opt">-e</option> per modificare il messaggio di commit della patch/changeset combinata dopo che l'inclusione è stata completata.</para>
+      <para id="x_5f2">I commenti delle patch incluse vengono aggiunti alla fine dei commenti della patch di destinazione, separando ogni blocco di commenti con tre caratteri di asterisco (<quote><literal>*</literal></quote>). Usate l&rsquo;opzione <option role="hg-ext-mq-cmd-qfold-opt">-e</option> per modificare il messaggio di commit della patch/changeset combinata dopo che l&rsquo;inclusione è stata completata.</para>
 
       <para id="x_5f3">Opzioni:</para>
       <itemizedlist>
 
     </sect2>
     <sect2>
-      <title><command role="hg-ext-mq">qheader</command>&emdash;mostra l'intestazione/descrizione di una patch</title>
+      <title><command role="hg-ext-mq">qheader</command>&emdash;mostra l&rsquo;intestazione/descrizione di una patch</title>
 
-      <para id="x_5f7">Il comando <command role="hg-ext-mq">qheader</command> stampa l'intestazione, o descrizione, di una patch. Per default, stampa l'intestazione dell'ultima patch applicata. Dato un argomento, stampa l'intestazione della patch indicata.</para>
+      <para id="x_5f7">Il comando <command role="hg-ext-mq">qheader</command> stampa l&rsquo;intestazione, o descrizione, di una patch. Per default, stampa l&rsquo;intestazione dell&rsquo;ultima patch applicata. Dato un argomento, stampa l&rsquo;intestazione della patch indicata.</para>
 
     </sect2>
     <sect2>
       <title><command role="hg-ext-mq">qimport</command>&emdash;importa una patch di terze parti nella coda</title>
 
-      <para id="x_5f8">Il comando <command role="hg-ext-mq">qimport</command> aggiunge una voce per una patch esterna al file <filename role="special">series</filename> e copia la patch nella directory <filename role="special" class="directory">.hg/patches</filename>. Aggiunge la voce immediatamente dopo l'ultima patch applicata, ma non inserisce la patch.</para>
+      <para id="x_5f8">Il comando <command role="hg-ext-mq">qimport</command> aggiunge una voce per una patch esterna al file <filename role="special">series</filename> e copia la patch nella directory <filename role="special" class="directory">.hg/patches</filename>. Aggiunge la voce immediatamente dopo l&rsquo;ultima patch applicata, ma non inserisce la patch.</para>
 
       <para id="x_5f9">Se la directory <filename role="special" class="directory">.hg/patches</filename> è un repository, <command role="hg-ext-mq">qimport</command> usa <command role="hg-cmd">hg add</command> per aggiungere automaticamente la patch importata.</para>
 
     <sect2>
       <title><command role="hg-ext-mq">qnew</command>&emdash;crea una nuova patch</title>
 
-      <para id="x_5fe">Il comando <command role="hg-ext-mq">qnew</command> crea una nuova patch. Prende come argomento obbligatorio il nome da usare per il file di patch. La nuova patch viene creata vuota per default, viene aggiunta al file <filename role="special">series</filename> dopo l'ultima patch applicata e viene immediatamente inserita sopra quella patch.</para>
+      <para id="x_5fe">Il comando <command role="hg-ext-mq">qnew</command> crea una nuova patch. Prende come argomento obbligatorio il nome da usare per il file di patch. La nuova patch viene creata vuota per default, viene aggiunta al file <filename role="special">series</filename> dopo l&rsquo;ultima patch applicata e viene immediatamente inserita sopra quella patch.</para>
 
-      <para id="x_5ff">Se <command role="hg-ext-mq">qnew</command> trova qualche file modificato nella directory di lavoro, si rifiuterà di creare una nuova patch a meno che non usiate l'opzione <option role="hg-ext-mq-cmd-qnew-opt">-f</option> (vedete più avanti). Questo comportamento vi permette di aggiornare l'ultima patch applicata tramite <command role="hg-ext-mq">qrefresh</command> prima di applicare una nuova patch.</para>
+      <para id="x_5ff">Se <command role="hg-ext-mq">qnew</command> trova qualche file modificato nella directory di lavoro, si rifiuterà di creare una nuova patch a meno che non usiate l&rsquo;opzione <option role="hg-ext-mq-cmd-qnew-opt">-f</option> (vedete più avanti). Questo comportamento vi permette di aggiornare l&rsquo;ultima patch applicata tramite <command role="hg-ext-mq">qrefresh</command> prima di applicare una nuova patch.</para>
 
       <para id="x_600">Opzioni:</para>
       <itemizedlist>
-	<listitem><para id="x_601"><option role="hg-ext-mq-cmd-qnew-opt">-f</option>: crea una nuova patch se il contenuto della directory di lavoro è stato modificato. Ogni cambiamento in sospeso viene aggiunto alla patch appena creata, pertanto al termine dell'esecuzione del comando la directory di lavoro non risulterà più modificata.</para>
+	<listitem><para id="x_601"><option role="hg-ext-mq-cmd-qnew-opt">-f</option>: crea una nuova patch se il contenuto della directory di lavoro è stato modificato. Ogni cambiamento in sospeso viene aggiunto alla patch appena creata, pertanto al termine dell&rsquo;esecuzione del comando la directory di lavoro non risulterà più modificata.</para>
 	</listitem>
-	<listitem><para id="x_602"><option role="hg-ext-mq-cmd-qnew-opt">-m</option>: usa il testo dato come messaggio di commit. Il testo verrà memorizzato all'inizio del file di patch, prima dei dati di patch.</para>
+	<listitem><para id="x_602"><option role="hg-ext-mq-cmd-qnew-opt">-m</option>: usa il testo dato come messaggio di commit. Il testo verrà memorizzato all&rsquo;inizio del file di patch, prima dei dati di patch.</para>
 	</listitem>
       </itemizedlist>
 
     <sect2>
       <title><command role="hg-ext-mq">qnext</command>&emdash;stampa il nome della patch successiva</title>
 
-      <para id="x_603">Il comando <command role="hg-ext-mq">qnext</command> stampa il nome della patch nel file <filename role="special">series</filename> che segue la patch applicata più recentemente. Questa patch diventerà l'ultima patch applicata se invocate <command role="hg-ext-mq">qpush</command>.</para>
+      <para id="x_603">Il comando <command role="hg-ext-mq">qnext</command> stampa il nome della patch nel file <filename role="special">series</filename> che segue la patch applicata più recentemente. Questa patch diventerà l&rsquo;ultima patch applicata se invocate <command role="hg-ext-mq">qpush</command>.</para>
 
     </sect2>
     <sect2>
 
       <para id="x_605">Questo comando rimuove dal repository i changeset che rappresentano le patch estratte e aggiorna la directory di lavoro per annullare gli effetti delle patch.</para>
 
-      <para id="x_606">Questo comando accetta un argomento opzionale che viene usato per indicare il nome o l'indice numerico della patch da estrarre. Se viene passato un nome, il comando continuerà a estrarre patch fino a quando la patch nominata sarà in cima alla pila delle patch applicate. Se viene passato un numero, <command role="hg-ext-mq">qpop</command> tratterà il numero come un indice d'accesso alle voci presenti nel file della serie, partendo da zero (le righe vuote e le righe contenenti solo commenti non vengono contate). Il comando continuerà a estrarre patch fino a quando la patch identificata dall'indice dato sarà in cima alla pila delle patch applicate.</para>
+      <para id="x_606">Questo comando accetta un argomento opzionale che viene usato per indicare il nome o l&rsquo;indice numerico della patch da estrarre. Se viene passato un nome, il comando continuerà a estrarre patch fino a quando la patch nominata sarà in cima alla pila delle patch applicate. Se viene passato un numero, <command role="hg-ext-mq">qpop</command> tratterà il numero come un indice d&rsquo;accesso alle voci presenti nel file della serie, partendo da zero (le righe vuote e le righe contenenti solo commenti non vengono contate). Il comando continuerà a estrarre patch fino a quando la patch identificata dall&rsquo;indice dato sarà in cima alla pila delle patch applicate.</para>
 
-      <para id="x_607">Il comando <command role="hg-ext-mq">qpop</command> non legge e non modifica né le patch né il file <filename role="special">series</filename>. Perciò, potete tranquillamente usare <command role="hg-ext-mq">qpop</command> su una patch che avete rimosso dal file <filename role="special">series</filename>, oppure su una patch che avete rinominato o completamente cancellato. Negli ultimi due casi, usate il nome che la patch aveva quando l'avete applicata.</para>
+      <para id="x_607">Il comando <command role="hg-ext-mq">qpop</command> non legge e non modifica né le patch né il file <filename role="special">series</filename>. Perciò, potete tranquillamente usare <command role="hg-ext-mq">qpop</command> su una patch che avete rimosso dal file <filename role="special">series</filename>, oppure su una patch che avete rinominato o completamente cancellato. Negli ultimi due casi, usate il nome che la patch aveva quando l&rsquo;avete applicata.</para>
 
-      <para id="x_608">Per default, il comando <command role="hg-ext-mq">qpop</command> non estrarrà alcuna patch se la directory di lavoro è stata modificata. Potete cambiare questo comportamento usando l'opzione <option role="hg-ext-mq-cmd-qpop-opt">-f</option>, che annulla tutte le modifiche nella directory di lavoro.</para>
+      <para id="x_608">Per default, il comando <command role="hg-ext-mq">qpop</command> non estrarrà alcuna patch se la directory di lavoro è stata modificata. Potete cambiare questo comportamento usando l&rsquo;opzione <option role="hg-ext-mq-cmd-qpop-opt">-f</option>, che annulla tutte le modifiche nella directory di lavoro.</para>
 
       <para id="x_609">Opzioni:</para>
       <itemizedlist>
 	<listitem><para id="x_60a"><option role="hg-ext-mq-cmd-qpop-opt">-a</option>: estrae tutte le patch applicate, riportando il repository allo stato in cui era prima che applicaste qualunque patch.</para>
 	</listitem>
-	<listitem><para id="x_60b"><option role="hg-ext-mq-cmd-qpop-opt">-f</option>: annulla forzatamente qualsiasi modifica alla directory di lavoro al momento dell'estrazione.</para>
+	<listitem><para id="x_60b"><option role="hg-ext-mq-cmd-qpop-opt">-f</option>: annulla forzatamente qualsiasi modifica alla directory di lavoro al momento dell&rsquo;estrazione.</para>
 	</listitem>
 	<listitem><para id="x_60c"><option role="hg-ext-mq-cmd-qpop-opt">-n</option>: estrae una patch dalla coda nominata.</para>
 	</listitem>
     <sect2>
       <title><command role="hg-ext-mq">qprev</command>&emdash;stampa il nome della patch precedente</title>
 
-      <para id="x_60e">Il comando <command role="hg-ext-mq">qprev</command> stampa il nome della patch nel file <filename role="special">series</filename> che precede la patch applicata più recentemente. Questa patch diventerà l'ultima patch applicata se invocate <command role="hg-ext-mq">qpop</command>.</para>
+      <para id="x_60e">Il comando <command role="hg-ext-mq">qprev</command> stampa il nome della patch nel file <filename role="special">series</filename> che precede la patch applicata più recentemente. Questa patch diventerà l&rsquo;ultima patch applicata se invocate <command role="hg-ext-mq">qpop</command>.</para>
 
     </sect2>
     <sect2 id="sec:mqref:cmd:qpush">
 
       <para id="x_611">I dati predefiniti usati per creare un changeset sono i seguenti.</para>
       <itemizedlist>
-	<listitem><para id="x_612">La data e il fuso orario del commit sono la data e il fuso orario corrente. Dato che questi dati vengono usati per computare l'identità di un changeset, questo significa che se invocate <command role="hg-ext-mq">qpop</command> su una patch e poi invocate <command role="hg-ext-mq">qpush</command> sulla stessa patch, il changeset che inserite avrà un'identità diversa dal changeset che avete estratto.</para>
+	<listitem><para id="x_612">La data e il fuso orario del commit sono la data e il fuso orario corrente. Dato che questi dati vengono usati per computare l&rsquo;identità di un changeset, questo significa che se invocate <command role="hg-ext-mq">qpop</command> su una patch e poi invocate <command role="hg-ext-mq">qpush</command> sulla stessa patch, il changeset che inserite avrà un&rsquo;identità diversa dal changeset che avete estratto.</para>
 	</listitem>
-	<listitem><para id="x_613">L'autore è quello predefinito usato dal comando <command role="hg-cmd">hg commit</command>.</para>
+	<listitem><para id="x_613">L&rsquo;autore è quello predefinito usato dal comando <command role="hg-cmd">hg commit</command>.</para>
 	</listitem>
 	<listitem><para id="x_614">Il messaggio di commit è il testo proveniente dal file di patch che precede la prima intestazione del diff. Se questo testo non è presente, viene usato un messaggio di commit predefinito che identifica il nome della patch.</para>
 	</listitem>
       </itemizedlist>
-      <para id="x_615">Se una patch contiene un'intestazione di patch Mercurial, i dati nell'intestazione di patch sostituiscono quelli predefiniti.</para>
+      <para id="x_615">Se una patch contiene un&rsquo;intestazione di patch Mercurial, i dati nell&rsquo;intestazione di patch sostituiscono quelli predefiniti.</para>
 
       <para id="x_616">Opzioni:</para>
       <itemizedlist>
 	</listitem>
 	<listitem><para id="x_618"><option role="hg-ext-mq-cmd-qpush-opt">-l</option>: aggiunge il nome della patch alla fine del messaggio di commit.</para>
 	</listitem>
-	<listitem><para id="x_619"><option role="hg-ext-mq-cmd-qpush-opt">-m</option>: se l'applicazione di una patch fallisce, usa la voce relativa alla patch contenuta in un'altra coda salvata per computare i parametri di un'unione a tre vie, effettuando poi l'unione a tre vie attraverso il normale meccanismo di unione di Mercurial. Usa il risultato dell'unione come nuovo contenuto della patch.</para>
+	<listitem><para id="x_619"><option role="hg-ext-mq-cmd-qpush-opt">-m</option>: se l&rsquo;applicazione di una patch fallisce, usa la voce relativa alla patch contenuta in un&rsquo;altra coda salvata per computare i parametri di un&rsquo;unione a tre vie, effettuando poi l&rsquo;unione a tre vie attraverso il normale meccanismo di unione di Mercurial. Usa il risultato dell&rsquo;unione come nuovo contenuto della patch.</para>
 	</listitem>
-	<listitem><para id="x_61a"><option role="hg-ext-mq-cmd-qpush-opt">-n</option>: usa la coda nominata se effettua un'unione durante l'inserimento.</para>
+	<listitem><para id="x_61a"><option role="hg-ext-mq-cmd-qpush-opt">-n</option>: usa la coda nominata se effettua un&rsquo;unione durante l&rsquo;inserimento.</para>
 	</listitem>
       </itemizedlist>
 
     </sect2>
     <sect2>
       <title><command
-	  role="hg-ext-mq">qrefresh</command>&emdash;aggiorna l'ultima patch applicata</title>
+	  role="hg-ext-mq">qrefresh</command>&emdash;aggiorna l&rsquo;ultima patch applicata</title>
 
-      <para id="x_61c">Il comando <command role="hg-ext-mq">qrefresh</command> aggiorna l'ultima patch applicata. Modifica la patch, rimuove il vecchio changeset che rappresentava la patch e crea un nuovo changeset per rappresentare la patch modificata.</para>
+      <para id="x_61c">Il comando <command role="hg-ext-mq">qrefresh</command> aggiorna l&rsquo;ultima patch applicata. Modifica la patch, rimuove il vecchio changeset che rappresentava la patch e crea un nuovo changeset per rappresentare la patch modificata.</para>
 
       <para id="x_61d">Il comando <command role="hg-ext-mq">qrefresh</command> si occupa delle seguenti modifiche.</para>
       <itemizedlist>
 	</listitem>
       </itemizedlist>
 
-      <para id="x_621">Anche se <command role="hg-ext-mq">qrefresh</command> non trova alcun cambiamento, ricrea comunque il changeset che rappresenta la patch. Questo produce una differenza tra l'identità del nuovo changeset e quella del precedente changeset che identificava la patch.</para>
+      <para id="x_621">Anche se <command role="hg-ext-mq">qrefresh</command> non trova alcun cambiamento, ricrea comunque il changeset che rappresenta la patch. Questo produce una differenza tra l&rsquo;identità del nuovo changeset e quella del precedente changeset che identificava la patch.</para>
 
       <para id="x_622">Opzioni:</para>
       <itemizedlist>
-	<listitem><para id="x_623"><option role="hg-ext-mq-cmd-qrefresh-opt">-e</option>: modifica il messaggio di commit e la descrizione della patch, usando l'editor di testo preferito.</para>
+	<listitem><para id="x_623"><option role="hg-ext-mq-cmd-qrefresh-opt">-e</option>: modifica il messaggio di commit e la descrizione della patch, usando l&rsquo;editor di testo preferito.</para>
 	</listitem>
 	<listitem><para id="x_624"><option role="hg-ext-mq-cmd-qrefresh-opt">-m</option>: modifica il messaggio di commit e la descrizione della patch, usando il testo dato.</para>
 	</listitem>
 
       <para id="x_626">Il comando <command role="hg-ext-mq">qrename</command> rinomina una patch e modifica la voce relativa alla patch nel file <filename role="special">series</filename>.</para>
 
-      <para id="x_627">Con un singolo argomento, <command role="hg-ext-mq">qrename</command> rinomina l'ultima patch applicata. Con due argomenti, cambia il nome del primo argomento al secondo argomento.</para>
+      <para id="x_627">Con un singolo argomento, <command role="hg-ext-mq">qrename</command> rinomina l&rsquo;ultima patch applicata. Con due argomenti, cambia il nome del primo argomento al secondo argomento.</para>
 
     </sect2>
     <sect2>
-      <title><command role="hg-ext-mq">qseries</command>&emdash;stampa l'intera serie di patch</title>
+      <title><command role="hg-ext-mq">qseries</command>&emdash;stampa l&rsquo;intera serie di patch</title>
 
-      <para id="x_62a">Il comando <command role="hg-ext-mq">qseries</command> stampa l'intera serie di patch contenuta nel file <filename role="special">series</filename>. Stampa solo i nomi delle patch, saltando le righe vuote e i commenti. Stampa le patch in ordine dalla prima patch da applicare all'ultima.</para>
+      <para id="x_62a">Il comando <command role="hg-ext-mq">qseries</command> stampa l&rsquo;intera serie di patch contenuta nel file <filename role="special">series</filename>. Stampa solo i nomi delle patch, saltando le righe vuote e i commenti. Stampa le patch in ordine dalla prima patch da applicare all&rsquo;ultima.</para>
 
     </sect2>
     <sect2>
       <title><command
 	  role="hg-ext-mq">qunapplied</command>&emdash;stampa le patch non ancora applicate</title>
 
-      <para id="x_62c">Il comando <command role="hg-ext-mq">qunapplied</command> stampa i nomi delle patch non ancora applicate contenute nel file <filename role="special">series</filename>, nell'ordine in cui le patch verrebbero inserite.</para>
+      <para id="x_62c">Il comando <command role="hg-ext-mq">qunapplied</command> stampa i nomi delle patch non ancora applicate contenute nel file <filename role="special">series</filename>, nell&rsquo;ordine in cui le patch verrebbero inserite.</para>
 
     </sect2>
     <sect2>
     <sect2>
       <title>Il file <filename role="special">series</filename></title>
 
-      <para id="x_633">Il file <filename role="special">series</filename> contiene una lista dei nomi di tutte le patch che MQ può applicare. Viene rappresentato come una lista di nomi, con un nome salvato per riga. Lo spazio bianco all'inizio e alla fine di ogni riga viene ignorato.</para>
+      <para id="x_633">Il file <filename role="special">series</filename> contiene una lista dei nomi di tutte le patch che MQ può applicare. Viene rappresentato come una lista di nomi, con un nome salvato per riga. Lo spazio bianco all&rsquo;inizio e alla fine di ogni riga viene ignorato.</para>
 
       <para id="x_634">Le righe possono contenere commenti. Un commento comincia con il carattere <quote><literal>#</literal></quote> e si estende fino alla fine della riga. Le righe vuote e le righe che contengono solo commenti vengono ignorate.</para>
 
-      <para id="x_635">Avrete spesso bisogno di modificare il file <filename role="special">series</filename> a mano, da cui il supporto per i commenti e le righe vuote appena descritto. Per esempio, potete commentare temporaneamente una patch in modo che <command role="hg-ext-mq">qpush</command> la salti quando applica le patch. Potete anche cambiare l'ordine in cui le patch vengono applicate riordinando le loro voci nel file <filename role="special">series</filename>.</para>
+      <para id="x_635">Avrete spesso bisogno di modificare il file <filename role="special">series</filename> a mano, da cui il supporto per i commenti e le righe vuote appena descritto. Per esempio, potete commentare temporaneamente una patch in modo che <command role="hg-ext-mq">qpush</command> la salti quando applica le patch. Potete anche cambiare l&rsquo;ordine in cui le patch vengono applicate riordinando le loro voci nel file <filename role="special">series</filename>.</para>
 
-      <para id="x_636">Viene anche supportata la possibilità di mettere il file <filename role="special">series</filename> sotto controllo di revisione. &Egrave; una buona idea mettere sotto controllo di revisione anche tutte le patch a cui il file si riferisce. Se create una directory di patch usando l'opzione <option role="hg-ext-mq-cmd-qinit-opt">-c</option> del comando <command role="hg-ext-mq">qinit</command>, questo verrà fatto per voi automaticamente.</para>
+      <para id="x_636">Viene anche supportata la possibilità di mettere il file <filename role="special">series</filename> sotto controllo di revisione. &Egrave; una buona idea mettere sotto controllo di revisione anche tutte le patch a cui il file si riferisce. Se create una directory di patch usando l&rsquo;opzione <option role="hg-ext-mq-cmd-qinit-opt">-c</option> del comando <command role="hg-ext-mq">qinit</command>, questo verrà fatto per voi automaticamente.</para>
 
     </sect2>
     <sect2>

it/appC-srcinstall.xml

     <orderedlist>
       <listitem><para id="x_5e1">Scaricate un archivio dei sorgenti recente da <ulink url="http://www.selenic.com/mercurial/download">http://www.selenic.com/mercurial/download</ulink>.</para>
       </listitem>
-      <listitem><para id="x_5e2">Estraete i contenuti dell'archivio:</para>
+      <listitem><para id="x_5e2">Estraete i contenuti dell&rsquo;archivio:</para>
 	<programlisting>gzip -dc mercurial-VERSIONE.tar.gz | tar xf -</programlisting>
       </listitem>
       <listitem><para id="x_5e3">Posizionatevi nella directory dei sorgenti ed eseguite lo script di installazione che assemblerà Mercurial e lo installerà nella vostra directory personale.</para>
 python setup.py install --force --home=$HOME</programlisting>
       </listitem>
     </orderedlist>
-    <para id="x_5e4">Una volta che l'installazione è terminata, Mercurial si troverà nella sottodirectory <literal>bin</literal> della vostra directory personale. Non dimenticate di assicurarvi che questa directory sia presente nel percorso di ricerca della vostra shell.</para>
+    <para id="x_5e4">Una volta che l&rsquo;installazione è terminata, Mercurial si troverà nella sottodirectory <literal>bin</literal> della vostra directory personale. Non dimenticate di assicurarvi che questa directory sia presente nel percorso di ricerca della vostra shell.</para>
 
-    <para id="x_5e5">Probabilmente avrete bisogno di impostare la variabile d'ambiente <envar>PYTHONPATH</envar> in modo che l'eseguibile di Mercurial possa trovare il resto dei pacchetti di Mercurial. Per esempio, sul mio portatile, ho impostato il valore di quella variabile a <literal>/home/bos/lib/python</literal>. Il percorso esatto dipende da come Python è stato installato sul vostro sistema, ma dovrebbe essere facile da scoprire. Se non siete sicuri, date un'occhiata alle informazioni precedentemente stampate dallo script di installazione e cercate il luogo in cui i contenuti della directory <literal>mercurial</literal> sono stati installati.</para>
+    <para id="x_5e5">Probabilmente avrete bisogno di impostare la variabile d&rsquo;ambiente <envar>PYTHONPATH</envar> in modo che l&rsquo;eseguibile di Mercurial possa trovare il resto dei pacchetti di Mercurial. Per esempio, sul mio portatile, ho impostato il valore di quella variabile a <literal>/home/bos/lib/python</literal>. Il percorso esatto dipende da come Python è stato installato sul vostro sistema, ma dovrebbe essere facile da scoprire. Se non siete sicuri, date un&rsquo;occhiata alle informazioni precedentemente stampate dallo script di installazione e cercate il luogo in cui i contenuti della directory <literal>mercurial</literal> sono stati installati.</para>
 
   </sect1>
   <sect1>
 
     <para id="x_5e6">Assemblare e installare Mercurial sotto Windows richiede una varietà di strumenti, una certa quantità di conoscenze tecniche e una considerevole dose di pazienza. Vi suggerisco vivamente di <emphasis>non</emphasis> seguire questa strada se siete un <quote>utente occasionale</quote>. A meno che non intendiate lavorare su Mercurial, vi raccomando invece di usare un pacchetto di installazione eseguibile.</para>
 
-    <para id="x_5e7">Se avete intenzione di assemblare Mercurial dai sorgenti su Windows, seguite le direttive <quote>pratiche</quote> sul wiki di Mercurial all'indirizzo <ulink url="http://www.selenic.com/mercurial/wiki/index.cgi/WindowsInstall">http://www.selenic.com/mercurial/wiki/index.cgi/WindowsInstall</ulink> e aspettatevi che il processo comporti lo svolgimento di numerose operazioni complicate.</para>
+    <para id="x_5e7">Se avete intenzione di assemblare Mercurial dai sorgenti su Windows, seguite le direttive <quote>pratiche</quote> sul wiki di Mercurial all&rsquo;indirizzo <ulink url="http://www.selenic.com/mercurial/wiki/index.cgi/WindowsInstall">http://www.selenic.com/mercurial/wiki/index.cgi/WindowsInstall</ulink> e aspettatevi che il processo comporti lo svolgimento di numerose operazioni complicate.</para>
 
   </sect1>
 </appendix>

it/appD-license.xml

     <para id="x_63a">Proper form for an incorporation by reference is as follows:</para>
 
     <blockquote>
-    <para id="x_63b">Copyright (c) <emphasis>year</emphasis> by <emphasis>author's name or designee</emphasis>. This material may be distributed only subject to the terms and conditions set forth in the Open Publication License, v<emphasis>x.y</emphasis> or later (the latest version is presently available at <ulink url="http://www.opencontent.org/openpub/">http://www.opencontent.org/openpub/</ulink>).</para>
+    <para id="x_63b">Copyright (c) <emphasis>year</emphasis> by <emphasis>author&rsquo;s name or designee</emphasis>. This material may be distributed only subject to the terms and conditions set forth in the Open Publication License, v<emphasis>x.y</emphasis> or later (the latest version is presently available at <ulink url="http://www.opencontent.org/openpub/">http://www.opencontent.org/openpub/</ulink>).</para>
     </blockquote>
 
     <para id="x_63c">The reference must be immediately followed with any options elected by the author(s) and/or publisher of the document (see <xref linkend="sec:opl:options"/>).</para>
 
     <para id="x_63d">Commercial redistribution of Open Publication-licensed material is permitted.</para>
 
-    <para id="x_63e">Any publication in standard (paper) book form shall require the citation of the original publisher and author. The publisher and author's names shall appear on all outer surfaces of the book. On all outer surfaces of the book the original publisher's name shall be as large as the title of the work and cited as possessive with respect to the title.</para>
+    <para id="x_63e">Any publication in standard (paper) book form shall require the citation of the original publisher and author. The publisher and author&rsquo;s names shall appear on all outer surfaces of the book. On all outer surfaces of the book the original publisher&rsquo;s name shall be as large as the title of the work and cited as possessive with respect to the title.</para>
 
   </sect1>
   <sect1>
       </listitem>
       <listitem><para id="x_648">The location of the original unmodified document must be identified.</para>
       </listitem>
-      <listitem><para id="x_649">The original author's (or authors') name(s) may not be used to assert or imply endorsement of the resulting document without the original author's (or authors') permission.</para>
+      <listitem><para id="x_649">The original author&rsquo;s (or authors&rsquo;) name(s) may not be used to assert or imply endorsement of the resulting document without the original author&rsquo;s (or authors&rsquo;) permission.</para>
       </listitem></orderedlist>
 
   </sect1>

it/book-shortcuts.xml

 <!-- Please keep the contents of this file sorted. -->
 
 <!ENTITY Agrave "&#192;">
+<!ENTITY rsquo "&#8217;">
 <!ENTITY Egrave "&#200;">
 <!ENTITY emdash "&#8212;">

it/ch00-preface.xml

 
     <para id="x_72e">Alcuni anni fa, quando cominciai a sentire il desiderio di spiegare perché credevo che il controllo di revisione distribuito fosse importante, questo campo era talmente nuovo che la letteratura pubblicata da offrire come riferimento alle persone interessate era quasi inesistente.</para>
 
-    <para id="x_72f">Sebbene a quel tempo fossi abbastanza impegnato a lavorare sui meccanismi interni di Mercurial, mi misi a scrivere questo libro perché sembrava il modo più efficace di aiutare il software a raggiungere il grande pubblico, accompagnandolo con l'idea che il controllo di revisione dovesse essere distribuito per natura. Rendo il libro disponibile online secondo i termini di una licenza liberale per la stessa ragione: per diffondere il messaggio.</para>
+    <para id="x_72f">Sebbene a quel tempo fossi abbastanza impegnato a lavorare sui meccanismi interni di Mercurial, mi misi a scrivere questo libro perché sembrava il modo più efficace di aiutare il software a raggiungere il grande pubblico, accompagnandolo con l&rsquo;idea che il controllo di revisione dovesse essere distribuito per natura. Rendo il libro disponibile online secondo i termini di una licenza liberale per la stessa ragione: per diffondere il messaggio.</para>
 
-    <para id="x_730">Un buon libro di software possiede un ritmo familiare che assomiglia da vicino al racconto di una storia: che cos'è questa cosa? Perché è importante? Come mi aiuterà? Come si usa? In questo libro, provo a rispondere a queste domande per il controllo di revisione distribuito in generale e per Mercurial in particolare.</para>
+    <para id="x_730">Un buon libro di software possiede un ritmo familiare che assomiglia da vicino al racconto di una storia: che cos&rsquo;è questa cosa? Perché è importante? Come mi aiuterà? Come si usa? In questo libro, provo a rispondere a queste domande per il controllo di revisione distribuito in generale e per Mercurial in particolare.</para>
   </sect1>
     
   <sect1>
     <title>Grazie per il vostro sostegno a Mercurial</title>
 
-    <para id="x_731">Acquistando una copia di questo libro state sostenendo il continuo sviluppo e la libertà ininterrotta di Mercurial in particolare e del software libero e open source in generale. O'Reilly Media e io stiamo donando le mie royalty sulle vendite di questo libro alla Software Freedom Conservancy (<ulink
+    <para id="x_731">Acquistando una copia di questo libro state sostenendo il continuo sviluppo e la libertà ininterrotta di Mercurial in particolare e del software libero e open source in generale. O&rsquo;Reilly Media e io stiamo donando le mie royalty sulle vendite di questo libro alla Software Freedom Conservancy (<ulink
 	url="http://www.softwarefreedom.org/">http://www.softwarefreedom.org/</ulink>) che fornisce supporto in termini di personale e di assistenza legale a Mercurial e a un certo numero di altri progetti software open source importanti e meritevoli.</para>
   </sect1>
 
   <sect1>
     <title>Ringraziamenti</title>
 
-    <para id="x_732">Questo libro non esisterebbe se non fosse per gli sforzi di Matt Mackall, l'autore e capo progetto di Mercurial. Lo assistono abilmente centinaia di collaboratori volontari sparsi in tutto il mondo.</para>
+    <para id="x_732">Questo libro non esisterebbe se non fosse per gli sforzi di Matt Mackall, l&rsquo;autore e capo progetto di Mercurial. Lo assistono abilmente centinaia di collaboratori volontari sparsi in tutto il mondo.</para>
 
     <para id="x_733">I miei figli, Cian e Ruairi, si sono sempre fatti trovare pronti per aiutarmi a rilassarmi con meravigliosi e spericolati giochi da bambini. Vorrei anche ringraziare la mia ex moglie, Shannon, per il suo supporto.</para>
 
     <para id="x_734">I miei colleghi e amici hanno fornito aiuto e sostegno in innumerevoli modi. Questa lista di persone non può che essere decisamente incompleta: Stephen Hahn, Karyn Ritter, Bonnie Corwin, James Vasile, Matt Norwood, Eben Moglen, Bradley Kuhn, Robert Walsh, Jeremy Fitzhardinge, Rachel Chalmers.</para>
 
-    <para id="x_735">Ho sviluppato questo libro pubblicamente, mettendo sul sito web del libro le bozze dei capitoli mano a mano che li completavo. I lettori mi hanno poi mandato le loro opinioni usando un'applicazione web da me creata. Al momento in cui ho terminato il libro, più di 100 persone avevano inviato il proprio parere, un numero impressionante considerando che il sistema di commenti è stato attivo solo per circa due mesi verso la fine del processo di scrittura.</para> 
+    <para id="x_735">Ho sviluppato questo libro pubblicamente, mettendo sul sito web del libro le bozze dei capitoli mano a mano che li completavo. I lettori mi hanno poi mandato le loro opinioni usando un&rsquo;applicazione web da me creata. Al momento in cui ho terminato il libro, più di 100 persone avevano inviato il proprio parere, un numero impressionante considerando che il sistema di commenti è stato attivo solo per circa due mesi verso la fine del processo di scrittura.</para> 
 
-    <para id="x_736">In particolare, vorrei esprimere la mia riconoscenza alle seguenti persone, che tra loro hanno contribuito più di un terzo del numero totale di commenti. Vorrei ringraziarli per la cura e l'impegno che hanno messo nel fornire un giudizio talmente tanto dettagliato.</para> 
+    <para id="x_736">In particolare, vorrei esprimere la mia riconoscenza alle seguenti persone, che tra loro hanno contribuito più di un terzo del numero totale di commenti. Vorrei ringraziarli per la cura e l&rsquo;impegno che hanno messo nel fornire un giudizio talmente tanto dettagliato.</para> 
 
     <para id="x_737">Martin Geisler, Damien Cassou, Alexey Bakhirkin, Till Plewe, Dan Himes, Paul Sargent, Gokberk Hamurcu, Matthijs van der Vleuten, Michael Chermside, John Mulligan, Jordi Fita, Jon Parise.</para>
 
         <term><literal>Spaziatura fissa</literal></term>
 
         <listitem>
-          <para id="x_73c">Usato per i listati dei programmi e all'interno di paragrafi che fanno riferimento a elementi di programmazione come variabili o nomi di funzione, database, tipi di dato, variabili d'ambiente, istruzioni e parole chiave.</para>
+          <para id="x_73c">Usato per i listati dei programmi e all&rsquo;interno di paragrafi che fanno riferimento a elementi di programmazione come variabili o nomi di funzione, database, tipi di dato, variabili d&rsquo;ambiente, istruzioni e parole chiave.</para>
         </listitem>
       </varlistentry>
 
         <term><userinput>Spaziatura fissa in grassetto</userinput></term>
 
         <listitem>
-          <para id="x_73d">Mostra comandi o altro testo che dovrebbe essere digitato letteralmente dall'utente.</para>
+          <para id="x_73d">Mostra comandi o altro testo che dovrebbe essere digitato letteralmente dall&rsquo;utente.</para>
         </listitem>
       </varlistentry>
 
         <term><replaceable>Spaziatura fissa in corsivo</replaceable></term>
 
         <listitem>
-          <para id="x_73e">Mostra testo che dovrebbe essere sostituito da valori forniti dall'utente oppure determinati dal contesto.</para>
+          <para id="x_73e">Mostra testo che dovrebbe essere sostituito da valori forniti dall&rsquo;utente oppure determinati dal contesto.</para>
         </listitem>
       </varlistentry>
     </variablelist>
   <sect1>
     <title>Usare gli esempi di codice</title>
 
-    <para id="x_741">Questo libro ha il compito di aiutarvi a svolgere il vostro lavoro. In generale, potete usare il codice che trovate in questo libro nei vostri programmi e nella vostra documentazione. Non è necessario che ci contattiate per chiedere il permesso, a meno che non stiate riproducendo una porzione significativa del codice. Per esempio, non avete bisogno di un permesso per scrivere un programma che usa diversi frammenti di codice estratti da questo libro, ma dovete richiedere un permesso se desiderate vendere o distribuire un CD-ROM di esempi tratti dai libri pubblicati da O'Reilly. Non ci vuole alcun permesso per rispondere a una domanda citando questo libro e riproducendo codice di esempio, ma dovete richiedere un permesso per incorporare nella documentazione di un vostro prodotto una quantità significativa di codice proveniente da questo libro.</para>
+    <para id="x_741">Questo libro ha il compito di aiutarvi a svolgere il vostro lavoro. In generale, potete usare il codice che trovate in questo libro nei vostri programmi e nella vostra documentazione. Non è necessario che ci contattiate per chiedere il permesso, a meno che non stiate riproducendo una porzione significativa del codice. Per esempio, non avete bisogno di un permesso per scrivere un programma che usa diversi frammenti di codice estratti da questo libro, ma dovete richiedere un permesso se desiderate vendere o distribuire un CD-ROM di esempi tratti dai libri pubblicati da O&rsquo;Reilly. Non ci vuole alcun permesso per rispondere a una domanda citando questo libro e riproducendo codice di esempio, ma dovete richiedere un permesso per incorporare nella documentazione di un vostro prodotto una quantità significativa di codice proveniente da questo libro.</para>
 
-    <para id="x_742">Apprezziamo, ma non richiediamo, l'attribuzione del materiale utilizzato. Un'attribuzione di solito include il titolo, l'autore, l'editore e il codice ISBN. Per esempio: “<emphasis>Titolo del libro</emphasis> di Qualche Autore. Copyright 2008 O’Reilly Media, Inc., 978-0-596-xxxx-x.”</para>
+    <para id="x_742">Apprezziamo, ma non richiediamo, l&rsquo;attribuzione del materiale utilizzato. Un&rsquo;attribuzione di solito include il titolo, l&rsquo;autore, l&rsquo;editore e il codice ISBN. Per esempio: “<emphasis>Titolo del libro</emphasis> di Qualche Autore. Copyright 2008 O’Reilly Media, Inc., 978-0-596-xxxx-x.”</para>
 
-    <para id="x_743">Se credete che il vostro utilizzo del codice di esempio ricada fuori dai confini della correttezza o dei permessi illustrati sopra, sentitevi liberi di contattarci all'indirizzo email <email>permissions@oreilly.com</email>.</para>
+    <para id="x_743">Se credete che il vostro utilizzo del codice di esempio ricada fuori dai confini della correttezza o dei permessi illustrati sopra, sentitevi liberi di contattarci all&rsquo;indirizzo email <email>permissions@oreilly.com</email>.</para>
   </sect1>
 
   <sect1>
     <title>Safari® Books Online</title>
 
     <note role="safarienabled">
-      <para id="x_744">Quando vedete un'icona Safari® Books Online sulla copertina del vostro libro tecnico preferito, questo significa che quel libro è disponibile attraverso la libreria Safari di O'Reilly Network.</para>
+      <para id="x_744">Quando vedete un&rsquo;icona Safari® Books Online sulla copertina del vostro libro tecnico preferito, questo significa che quel libro è disponibile attraverso la libreria Safari di O&rsquo;Reilly Network.</para>
     </note>
 
-    <para id="x_745">Safari offre una soluzione più vantaggiosa rispetto agli e-book. &Egrave; una libreria virtuale che vi permette di effettuare facilmente ricerche su migliaia di libri tecnici, copiare e incollare gli esempi di codice, scaricare capitoli e trovare risposte veloci quando avete bisogno delle informazioni più accurate e recenti. Provatelo gratis all'indirizzo <ulink role="orm:hideurl:ital"
+    <para id="x_745">Safari offre una soluzione più vantaggiosa rispetto agli e-book. &Egrave; una libreria virtuale che vi permette di effettuare facilmente ricerche su migliaia di libri tecnici, copiare e incollare gli esempi di codice, scaricare capitoli e trovare risposte veloci quando avete bisogno delle informazioni più accurate e recenti. Provatelo gratis all&rsquo;indirizzo <ulink role="orm:hideurl:ital"
 	url="http://my.safaribooksonline.com/?portal=oreilly">http://my.safaribooksonline.com</ulink>.</para>
   </sect1>
 
   <sect1>
     <title>Come contattarci</title>
 
-    <para id="x_746">Per favore spedite commenti e domande riguardanti questo libro all'editore:</para>
+    <para id="x_746">Per favore spedite commenti e domande riguardanti questo libro all&rsquo;editore:</para>
 
     <simplelist type="vert">
       <member>O’Reilly Media, Inc.</member>
       <member>707 829-0104 (fax)</member>
     </simplelist>
 
-    <para id="x_747">Abbiamo predisposto una pagina web dedicata a questo libro, dove elenchiamo errata, esempi e qualsivoglia informazione aggiuntiva. Potete accedere a questa pagina (relativa alla versione inglese del libro) all'indirizzo:</para>
+    <para id="x_747">Abbiamo predisposto una pagina web dedicata a questo libro, dove elenchiamo errata, esempi e qualsivoglia informazione aggiuntiva. Potete accedere a questa pagina (relativa alla versione inglese del libro) all&rsquo;indirizzo:</para>
 
     <simplelist type="vert">
       <member><ulink url="http://www.oreilly.com/catalog/9780596800673"></ulink></member>
     </simplelist>
 
-    <para id="x_748">Per inviare un commento o porre domande tecniche su questo libro, spedite un'email a:</para>
+    <para id="x_748">Per inviare un commento o porre domande tecniche su questo libro, spedite un&rsquo;email a:</para>
 
     <simplelist type="vert">
       <member><email>bookquestions@oreilly.com</email></member>
     </simplelist>
 
-    <para id="x_749">Per maggiori informazioni sui nostri libri, sulle conferenze, sui Centri di Risorse, e su O'Reilly Network, visitate il nostro sito web all'indirizzo:</para>
+    <para id="x_749">Per maggiori informazioni sui nostri libri, sulle conferenze, sui Centri di Risorse, e su O&rsquo;Reilly Network, visitate il nostro sito web all&rsquo;indirizzo:</para>
 
     <simplelist type="vert">
       <member><ulink url="http://www.oreilly.com"></ulink></member>

it/ch01-intro.xml

 
     <para id="x_6d">Il controllo di revisione è il processo tramite il quale si gestiscono molteplici versioni di una qualsiasi unità di informazione. Molte persone eseguono a mano questo processo nella sua forma più semplice, ogni volta che modificano un file e lo salvano con un nuovo nome che contiene un numero più alto del numero della versione precedente.</para>
 
-    <para id="x_6e">Tuttavia, gestire più versioni anche solo di un singolo file è un'operazione soggetta a errori, quindi gli strumenti software per automatizzare questo processo sono stati disponibili per molto tempo. I primi strumenti automatizzati per il controllo di revisione erano deputati ad assistere un singolo utente nella gestione delle revisioni di un singolo file. Nel corso delle ultime decadi, il campo d'azione degli strumenti di controllo di revisione si è ampiamente esteso, e ora sono in grado di gestire un grande numero di file e di aiutare più persone a lavorare insieme. I migliori strumenti moderni di controllo di revisione non hanno alcun problema a fronteggiare gruppi di migliaia di persone che lavorano insieme su progetti composti da centinaia di migliaia di file.</para>
+    <para id="x_6e">Tuttavia, gestire più versioni anche solo di un singolo file è un&rsquo;operazione soggetta a errori, quindi gli strumenti software per automatizzare questo processo sono stati disponibili per molto tempo. I primi strumenti automatizzati per il controllo di revisione erano deputati ad assistere un singolo utente nella gestione delle revisioni di un singolo file. Nel corso delle ultime decadi, il campo d&rsquo;azione degli strumenti di controllo di revisione si è ampiamente esteso, e ora sono in grado di gestire un grande numero di file e di aiutare più persone a lavorare insieme. I migliori strumenti moderni di controllo di revisione non hanno alcun problema a fronteggiare gruppi di migliaia di persone che lavorano insieme su progetti composti da centinaia di migliaia di file.</para>
 
-    <para id="x_6f">La comparsa del controllo di revisione distribuito è relativamente recente, e finora questo nuovo campo si è sviluppato grazie alla propensione umana per l'esplorazione di territori sconosciuti.</para>
+    <para id="x_6f">La comparsa del controllo di revisione distribuito è relativamente recente, e finora questo nuovo campo si è sviluppato grazie alla propensione umana per l&rsquo;esplorazione di territori sconosciuti.</para>
 
     <para id="x_70">Sto scrivendo un libro sul controllo di revisione distribuito perché credo che sia una materia importante che merita una guida sul campo. Ho scelto di trattare Mercurial perché è lo strumento più facile con cui saggiare il terreno, e tuttavia è in grado di scalare fino a soddisfare le richieste di ambienti reali e impegnativi dove molti altri strumenti di controllo di revisione si sono dovuti arrendere.</para>
 
       <para id="x_71">Esiste un certo numero di ragioni per le quali voi o il vostro gruppo potreste voler usare uno strumento automatico per il controllo di revisione su un progetto.</para>
 
       <itemizedlist>
-	<listitem><para id="x_72">Lo strumento terrà traccia della storia e dell'evoluzione del vostro progetto, così voi non dovete farlo. Per ogni modifica, registrerà informazioni riguardanti <emphasis>chi</emphasis> l'ha fatta, <emphasis>perché</emphasis> l'ha fatta, <emphasis>quando</emphasis> è stata fatta e <emphasis>cosa</emphasis> è stato modificato.</para></listitem>
+	<listitem><para id="x_72">Lo strumento terrà traccia della storia e dell&rsquo;evoluzione del vostro progetto, così voi non dovete farlo. Per ogni modifica, registrerà informazioni riguardanti <emphasis>chi</emphasis> l&rsquo;ha fatta, <emphasis>perché</emphasis> l&rsquo;ha fatta, <emphasis>quando</emphasis> è stata fatta e <emphasis>cosa</emphasis> è stato modificato.</para></listitem>
 	<listitem><para id="x_73">Quando state lavorando con altre persone, il software di controllo di revisione facilita la collaborazione. Per esempio, quando due persone effettuano cambiamenti incompatibili più o meno simultaneamente, il software vi aiuterà a identificare e risolvere questi conflitti.</para></listitem>
 	<listitem><para id="x_74">Lo strumento può aiutarvi a rettificare i vostri errori. Se fate una modifica che più tardi si rivela essere un errore, potete ritornare a una versione precedente di uno o più file. In effetti, uno strumento di controllo di revisione <emphasis>davvero</emphasis> buono vi aiuterà a calcolare efficientemente il momento esatto in cui un problema è stato introdotto (si veda la <xref linkend="sec:undo:bisect"/> per i dettagli).</para></listitem>
-	<listitem><para id="x_75">Il software vi aiuterà a lavorare simultaneamente su molteplici versioni del vostro progetto e a gestire gli spostamenti tra una versione e l'altra.</para></listitem>
+	<listitem><para id="x_75">Il software vi aiuterà a lavorare simultaneamente su molteplici versioni del vostro progetto e a gestire gli spostamenti tra una versione e l&rsquo;altra.</para></listitem>
       </itemizedlist>
 
       <para id="x_76">La maggior parte di queste ragioni sono altrettanto valide&emdash;almeno in teoria&emdash;sia che lavoriate su un progetto da soli sia che collaboriate insieme a un centianio di altre persone.</para>
 
       <para id="x_78">&Egrave; probabile che un progetto di cinquecento persone collassi quasi immediatamente sotto il proprio peso senza un processo e uno strumento di controllo di revisione. In questo caso, il costo di usare il controllo di revisione potrebbe sembrare difficilmente meritevole di considerazione, dato che <emphasis>senza</emphasis> di esso il fallimento del progetto è quasi garantito.</para>
 
-      <para id="x_79">D'altra parte, il <quote>lavoretto veloce</quote> di una singola persona potrebbe sembrare il contesto meno adatto per impiegare uno strumento di controllo di revisione, perché sicuramente il costo di usarne uno deve essere vicino al costo complessivo del progetto. Giusto?</para>
+      <para id="x_79">D&rsquo;altra parte, il <quote>lavoretto veloce</quote> di una singola persona potrebbe sembrare il contesto meno adatto per impiegare uno strumento di controllo di revisione, perché sicuramente il costo di usarne uno deve essere vicino al costo complessivo del progetto. Giusto?</para>
 
       <para id="x_7a">Mercurial supporta in maniera unica <emphasis>entrambe</emphasis> queste dimensioni di sviluppo. Potete impararne le basi in pochi minuti appena, e grazie al suo basso costo di gestione potete applicare il controllo di revisione al più piccolo dei progetti con facilità. La sua semplicità vi permetterà di concentrarvi su qualunque cosa stiate <emphasis>davvero</emphasis> cercando di fare senza distrarvi con schiere di concetti astrusi o lunghe sequenze di comandi. Allo stesso tempo, le elevate prestazioni e la natura peer-to-peer di Mercurial vi permetteranno di scalare in maniera indolore per gestire grandi progetti.</para>
 
 	<listitem><para id="x_80">controllo del codice sorgente, o controllo dei sorgenti;</para></listitem>
 	<listitem><para id="x_81">controllo di versione (VCS).</para></listitem>
       </itemizedlist>
-      <para id="x_82">Alcune persone affermano che questi termini in realtà abbiano significati differenti, ma in pratica essi si sovrappongono così tanto che non c'è alcun modo concordato o persino utile di distinguerli.</para>
+      <para id="x_82">Alcune persone affermano che questi termini in realtà abbiano significati differenti, ma in pratica essi si sovrappongono così tanto che non c&rsquo;è alcun modo concordato o persino utile di distinguerli.</para>
 
     </sect2>
   </sect1>
   <sect1>
     <title>A proposito degli esempi in questo libro</title>
 
-    <para id="x_84">Questo libro tratta gli esempi di codice in maniera inusuale. Tutti gli esempi sono <quote>vivi</quote>&emdash;ognuno di essi è in effetti il risultato di uno script di shell che esegue i comandi Mercurial che vedete. Ogni volta che un'immagine del libro viene assemblata dai suoi sorgenti, tutti gli script di esempio vengono automaticamente eseguiti e i loro risultati correnti vengono confrontati con i loro risultati attesi.</para>
+    <para id="x_84">Questo libro tratta gli esempi di codice in maniera inusuale. Tutti gli esempi sono <quote>vivi</quote>&emdash;ognuno di essi è in effetti il risultato di uno script di shell che esegue i comandi Mercurial che vedete. Ogni volta che un&rsquo;immagine del libro viene assemblata dai suoi sorgenti, tutti gli script di esempio vengono automaticamente eseguiti e i loro risultati correnti vengono confrontati con i loro risultati attesi.</para>
 
     <para id="x_85">Il vantaggio di questo approccio è che gli esempi sono sempre accurati, in quanto descrivono <emphasis>esattamente</emphasis> il comportamento della versione di Mercurial menzionata sulla copertina del libro. Se aggiorno la versione di Mercurial che sto documentando e il risultato di qualche comando cambia, il processo di assemblaggio del libro fallisce.</para>
 
-    <para id="x_86">C'è un piccolo svantaggio in questo approccio: le date e gli orari che vedete negli esempi tendono a venire <quote>compressi</quote> insieme in modo anomalo, diversamente da quanto accadrebbe se gli stessi comandi fossero digitati da un essere umano. Laddove un essere umano non può inviare più di un comando ogni pochi secondi, le cui marcature temporali sarebbero analogamente intervallate, i miei script d'esempio automatizzati sono in grado di eseguire molti comandi in un secondo.</para>
+    <para id="x_86">C&rsquo;è un piccolo svantaggio in questo approccio: le date e gli orari che vedete negli esempi tendono a venire <quote>compressi</quote> insieme in modo anomalo, diversamente da quanto accadrebbe se gli stessi comandi fossero digitati da un essere umano. Laddove un essere umano non può inviare più di un comando ogni pochi secondi, le cui marcature temporali sarebbero analogamente intervallate, i miei script d&rsquo;esempio automatizzati sono in grado di eseguire molti comandi in un secondo.</para>
 
-    <para id="x_87">Come conseguenza di questo fatto, potrebbe sembrare che molti inserimenti (in inglese, commit) consecutivi vengano eseguiti durante lo stesso secondo. Potete osservare la presenza di questa anomalia nell'esempio di <literal role="hg-ext">bisect</literal> nella <xref linkend="sec:undo:bisect"/>, tanto per farvi un'idea.</para>
+    <para id="x_87">Come conseguenza di questo fatto, potrebbe sembrare che molti inserimenti (in inglese, commit) consecutivi vengano eseguiti durante lo stesso secondo. Potete osservare la presenza di questa anomalia nell&rsquo;esempio di <literal role="hg-ext">bisect</literal> nella <xref linkend="sec:undo:bisect"/>, tanto per farvi un&rsquo;idea.</para>
 
     <para id="x_88">Quindi, mentre leggete gli esempi, non date troppo peso alle date e agli orari che vedete nei risultati dei comandi, ma fate <emphasis>decisamente</emphasis> affidamento sulla consistenza e riproducibilità del comportamento illustrato.</para>
 
   <sect1>
     <title>Le tendenze nel campo</title>
 
-    <para id="x_89">Ci sono state alcune inconfondibili tendenze nello sviluppo e nell'utilizzo degli strumenti di controllo di revisione nel corso delle ultime quattro decadi, man mano che le persone acquisivano familiarità con le capacità dei loro strumenti e venivano vincolate dai loro limiti.</para>
+    <para id="x_89">Ci sono state alcune inconfondibili tendenze nello sviluppo e nell&rsquo;utilizzo degli strumenti di controllo di revisione nel corso delle ultime quattro decadi, man mano che le persone acquisivano familiarità con le capacità dei loro strumenti e venivano vincolate dai loro limiti.</para>
 
     <para id="x_8a">La prima generazione ha cominciato col gestire singoli file su singoli computer. Sebbene questi strumenti rappresentassero un enorme progresso rispetto al controllo di revisione manuale effettuato ad hoc, il loro modello di bloccaggio (in inglese, locking) e la restrizione a un singolo computer limitarono il loro impiego a piccoli gruppi strettamente uniti.</para>
 
-    <para id="x_8b">La seconda generazione ha rilassato questi vincoli spostandosi su architetture di rete e gestendo interi progetti alla volta. Con l'aumentare delle dimensioni dei progetti, gli strumenti incontrarono nuovi problemi. A causa della frequenza elevata con cui i client avevano bisogno di parlare con i server, la scalabilità dei server divenne un problema per progetti di grandi dimensioni. Una connessione di rete inaffidabile poteva completamente impedire agli utenti remoti di parlare con il server. Man mano che i progetti open source cominciarono a rendere l'accesso in sola lettura disponibile a chiunque in forma anonima, persone senza privilegi di inserimento scoprivano di non poter usare gli strumenti per interagire con un progetto in modo naturale, in quanto non erano in grado di registrare le modifiche da loro effettuate.</para>
+    <para id="x_8b">La seconda generazione ha rilassato questi vincoli spostandosi su architetture di rete e gestendo interi progetti alla volta. Con l&rsquo;aumentare delle dimensioni dei progetti, gli strumenti incontrarono nuovi problemi. A causa della frequenza elevata con cui i client avevano bisogno di parlare con i server, la scalabilità dei server divenne un problema per progetti di grandi dimensioni. Una connessione di rete inaffidabile poteva completamente impedire agli utenti remoti di parlare con il server. Man mano che i progetti open source cominciarono a rendere l&rsquo;accesso in sola lettura disponibile a chiunque in forma anonima, persone senza privilegi di inserimento scoprivano di non poter usare gli strumenti per interagire con un progetto in modo naturale, in quanto non erano in grado di registrare le modifiche da loro effettuate.</para>
 
     <para id="x_8c">La generazione attuale degli strumenti di controllo di revisione è di natura peer-to-peer. Tutti questi sistemi hanno abbandonato la dipendenza da un singolo server centrale e permettono alle persone di distribuire i propri dati di controllo di revisione laddove sono effettivamente necessari. La collaborazione attraverso Internet non è più vincolata dalla tecnologia, ma è diventata una questione di scelta e consenso. Gli strumenti moderni possono operare offline indefinitamente e autonomamente, utilizzando una connessione di rete solo quando è necessario sincronizzare i cambiamenti con un altro repository.</para>
 
 
     <para id="x_8d">Sebbene per diversi anni gli stumenti per il controllo di revisione distribuito si siano mantenuti robusti e usabili tanto quanto le loro controparti delle generazioni precedenti, questo non vuol dire che le persone che utilizzavano strumenti più vecchi si siano necessariamente accorte dei loro vantaggi. Ci sono diversi modi in cui gli strumenti distribuiti brillano rispetto a quelli centralizzati.</para>
 
-    <para id="x_8e">Per un singolo sviluppatore, gli strumenti distribuiti sono quasi sempre più veloci di quelli centralizzati. Questo avviene per una semplice ragione: uno strumento centralizzato ha bisogno di utilizzare la rete per molte operazioni comuni, perché la maggior parte dei metadati sono memorizzati in una singola copia sul server centrale. Uno strumento distribuito memorizza tutti i suoi metadati localmente. A parità di altre condizioni, utilizzare la rete aggiunge un costo supplementare a uno strumento centralizzato. Non sottovalutate l'importanza di uno strumento veloce e reattivo: vi troverete a passare molto tempo interagendo con il vostro software di controllo di revisione.</para>
+    <para id="x_8e">Per un singolo sviluppatore, gli strumenti distribuiti sono quasi sempre più veloci di quelli centralizzati. Questo avviene per una semplice ragione: uno strumento centralizzato ha bisogno di utilizzare la rete per molte operazioni comuni, perché la maggior parte dei metadati sono memorizzati in una singola copia sul server centrale. Uno strumento distribuito memorizza tutti i suoi metadati localmente. A parità di altre condizioni, utilizzare la rete aggiunge un costo supplementare a uno strumento centralizzato. Non sottovalutate l&rsquo;importanza di uno strumento veloce e reattivo: vi troverete a passare molto tempo interagendo con il vostro software di controllo di revisione.</para>
 
-    <para id="x_8f">Gli strumenti distribuiti sono indifferenti alle stravaganze dell'infrastruttura dei vostri server, sempre perché replicano i metadati in così tanti luoghi. Se usate un sistema centralizzato e il vostro server si guasta, fareste meglio a sperare che il vostro sistema di backup sia affidabile e che il vostro ultimo backup sia recente ed effettivamente funzionante. Con uno strumento distribuito, avete molti backup disponibili sui computer di ogni singolo collaboratore.</para>
+    <para id="x_8f">Gli strumenti distribuiti sono indifferenti alle stravaganze dell&rsquo;infrastruttura dei vostri server, sempre perché replicano i metadati in così tanti luoghi. Se usate un sistema centralizzato e il vostro server si guasta, fareste meglio a sperare che il vostro sistema di backup sia affidabile e che il vostro ultimo backup sia recente ed effettivamente funzionante. Con uno strumento distribuito, avete molti backup disponibili sui computer di ogni singolo collaboratore.</para>
 
-    <para id="x_90">L'affidabilità della vostra rete influenzerà gli strumenti distribuiti in misura molto minore rispetto a quelli centralizzati. Non potete nemmeno usare uno strumento centralizzato senza una connessione di rete, a parte alcuni comandi estremamente limitati. Con uno strumento distribuito, potreste persino non notare se la vostra connessione di rete cade mentre state lavorando. L'unica cosa che non sarete in grado di fare è comunicare con i repository su altri computer, qualcosa che è relativamente raro rispetto alle operazioni locali. Questo potrebbe essere significativo solo se avete un gruppo di collaboratori sparpagliati in giro per il mondo.</para>
+    <para id="x_90">L&rsquo;affidabilità della vostra rete influenzerà gli strumenti distribuiti in misura molto minore rispetto a quelli centralizzati. Non potete nemmeno usare uno strumento centralizzato senza una connessione di rete, a parte alcuni comandi estremamente limitati. Con uno strumento distribuito, potreste persino non notare se la vostra connessione di rete cade mentre state lavorando. L&rsquo;unica cosa che non sarete in grado di fare è comunicare con i repository su altri computer, qualcosa che è relativamente raro rispetto alle operazioni locali. Questo potrebbe essere significativo solo se avete un gruppo di collaboratori sparpagliati in giro per il mondo.</para>
 
     <sect2>
       <title>Vantaggi per i progetti open source</title>
 
 	<para id="x_92">&Egrave; stato suggerito che gli strumenti per il controllo di revisione distribuito espongano i progetti open source a un certo tipo di rischio in quanto rendono estremamente facile <quote>biforcare</quote> (in inglese, fork) lo sviluppo di un progetto. Un fork avviene quando le differenze di opinione o di atteggiamento tra sviluppatori di uno stesso gruppo li portano a decidere di non poter lavorare più a lungo insieme. Ogni parte prende una copia più o meno completa del codice sorgente del progetto e prosegue per la propria strada.</para>
 
-	<para id="x_93">Talvolta le parti di un fork decidono di riconciliare le loro differenze. Con uno strumento centralizzato di controllo di revisione, il processo <emphasis>tecnico</emphasis> di riconciliazione è doloroso e deve essere in gran parte effettuato a mano. Dovete decidere quale cronologia delle revisioni dovrà <quote>prevalere</quote> e introdurvi in qualche modo i cambiamenti dell'altro gruppo. Di solito, questo risulta nella perdita parziale o completa della cronologia delle revisioni di una delle due parti.</para>
+	<para id="x_93">Talvolta le parti di un fork decidono di riconciliare le loro differenze. Con uno strumento centralizzato di controllo di revisione, il processo <emphasis>tecnico</emphasis> di riconciliazione è doloroso e deve essere in gran parte effettuato a mano. Dovete decidere quale cronologia delle revisioni dovrà <quote>prevalere</quote> e introdurvi in qualche modo i cambiamenti dell&rsquo;altro gruppo. Di solito, questo risulta nella perdita parziale o completa della cronologia delle revisioni di una delle due parti.</para>
 
-	<para id="x_94">Gli strumenti distribuiti rendono la biforcazione <emphasis>l'unico</emphasis> modo per sviluppare un progetto. Ogni singolo cambiamento apportato è un potenziale punto di biforcazione. La grande forza di questo approccio è che uno strumento per il controllo di revisione distribuito deve essere davvero bravo a <emphasis>unire</emphasis> (in inglese, merge) due fork, perché i fork sono assolutamente fondamentali: vengono effettuati in ogni momento.</para>
+	<para id="x_94">Gli strumenti distribuiti rendono la biforcazione <emphasis>l&rsquo;unico</emphasis> modo per sviluppare un progetto. Ogni singolo cambiamento apportato è un potenziale punto di biforcazione. La grande forza di questo approccio è che uno strumento per il controllo di revisione distribuito deve essere davvero bravo a <emphasis>unire</emphasis> (in inglese, merge) due fork, perché i fork sono assolutamente fondamentali: vengono effettuati in ogni momento.</para>
 
 	<para id="x_95">Se tutte le attività che ogni sviluppatore svolge in ogni momento vengono concepite in termini di biforcazioni e unioni, allora ciò che il mondo open source chiama <quote>fork</quote> diventa un problema <emphasis>puramente</emphasis> sociale. Gli strumenti distribuiti in realtà non fanno altro che <emphasis>ridurre</emphasis> la probabilità di un vero e proprio fork:</para>
 	<itemizedlist>
-	  <listitem><para id="x_96">eliminano la distinzione sociale imposta dagli strumenti centralizzati, cioè quella tra le persone all'interno del gruppo con i permessi di inserimento e le persone che si trovano all'esterno del gruppo e non hanno questi permessi;</para></listitem>
-	  <listitem><para id="x_97">rendono più facile riconciliarsi dopo un fork sociale, perché l'unica operazione che viene coinvolta dal punto di vista del software di controllo di revisione è semplicemente un'altra unione.</para></listitem>
+	  <listitem><para id="x_96">eliminano la distinzione sociale imposta dagli strumenti centralizzati, cioè quella tra le persone all&rsquo;interno del gruppo con i permessi di inserimento e le persone che si trovano all&rsquo;esterno del gruppo e non hanno questi permessi;</para></listitem>
+	  <listitem><para id="x_97">rendono più facile riconciliarsi dopo un fork sociale, perché l&rsquo;unica operazione che viene coinvolta dal punto di vista del software di controllo di revisione è semplicemente un&rsquo;altra unione.</para></listitem>
     </itemizedlist>
 
-	<para id="x_98">Alcune persone oppongono resistenza agli strumenti distribuiti perché vogliono mantenere uno stretto controllo sui propri progetti e credono che gli strumenti centralizzati diano loro questo controllo. Tuttavia, se siete tra quelli che hanno questa convinzione, e il vostro repository CVS o Subversion è disponibile pubblicamente, sappiate che esistono numerosi strumenti in grado di estrarre l'intera cronologia del vostro progetto (anche se lentamente) e ricrearla da qualche altra parte al di là del vostro controllo. Quindi non solo il vostro controllo in questo caso è illusorio, ma state anche rinunciando alla possibilità di collaborare facilmente con chiunque si senta in dovere di duplicare la cronologia del vostro progetto.</para>
+	<para id="x_98">Alcune persone oppongono resistenza agli strumenti distribuiti perché vogliono mantenere uno stretto controllo sui propri progetti e credono che gli strumenti centralizzati diano loro questo controllo. Tuttavia, se siete tra quelli che hanno questa convinzione, e il vostro repository CVS o Subversion è disponibile pubblicamente, sappiate che esistono numerosi strumenti in grado di estrarre l&rsquo;intera cronologia del vostro progetto (anche se lentamente) e ricrearla da qualche altra parte al di là del vostro controllo. Quindi non solo il vostro controllo in questo caso è illusorio, ma state anche rinunciando alla possibilità di collaborare facilmente con chiunque si senta in dovere di duplicare la cronologia del vostro progetto.</para>
 
       </sect3>
     </sect2>
     <sect2>
       <title>Vantaggi per i progetti commerciali</title>
 
-      <para id="x_99">Molti progetti commerciali vengono intrapresi da gruppi i cui membri sono sparpagliati attraverso il globo. I collaboratori lontani da un server centrale soffriranno un maggiore lentezza nell'esecuzione dei comandi e forse una minore affidabilità. I sistemi commerciali di controllo di revisione tentano di mitigare questi problemi tramite componenti aggiuntivi per la replicazione di siti remoti che sono tipicamente costosi da acquistare e complicati da amministrare. Un sistema distribuito non soffre di questi problemi in prima istanza. Ancora meglio, potete facilmente configurare molteplici server autoritativi, diciamo uno per ogni sito, in modo che non ci siano comunicazioni ridondanti tra i repository durante i costosi collegamenti di rete a grande distanza.</para>
+      <para id="x_99">Molti progetti commerciali vengono intrapresi da gruppi i cui membri sono sparpagliati attraverso il globo. I collaboratori lontani da un server centrale soffriranno un maggiore lentezza nell&rsquo;esecuzione dei comandi e forse una minore affidabilità. I sistemi commerciali di controllo di revisione tentano di mitigare questi problemi tramite componenti aggiuntivi per la replicazione di siti remoti che sono tipicamente costosi da acquistare e complicati da amministrare. Un sistema distribuito non soffre di questi problemi in prima istanza. Ancora meglio, potete facilmente configurare molteplici server autoritativi, diciamo uno per ogni sito, in modo che non ci siano comunicazioni ridondanti tra i repository durante i costosi collegamenti di rete a grande distanza.</para>
 
       <para id="x_9a">I sistemi centralizzati di controllo di revisione tendono ad avere una scalabilità relativamente bassa. Non è inusuale che un costoso sistema centralizzato cada sotto il carico combinato di una sola dozzina di utenti concorrenti. Ancora una volta, la tipica contromisura tende a essere un dispositivo di replicazione costoso e macchinoso. Dato che con uno strumento distribuito il carico su un server centrale&emdash;sempre che ne abbiate uno&emdash;è molto più basso (perché tutti i dati sono replicati ovunque), un singolo server economico può gestire i bisogni di un gruppo di lavoro molto più grande, e la replicazione per il bilancio del carico diventa una semplice questione di programmazione.</para>
 
-      <para id="x_9b">I vostri impiegati potranno beneficiare del controllo di versione distribuito anche quando si trovano nella sede di un cliente per risolvere un problema in loco. Gli strumenti permetteranno loro di generare versioni personalizzate del software nel repository, provare soluzioni differenti isolandole l'una dall'altra e cercare in maniera efficiente attraverso la cronologia delle revisioni le sorgenti di bug e regressioni nell'ambiente del cliente, il tutto senza aver bisogno di collegarsi alla rete della vostra azienda.</para>
+      <para id="x_9b">I vostri impiegati potranno beneficiare del controllo di versione distribuito anche quando si trovano nella sede di un cliente per risolvere un problema in loco. Gli strumenti permetteranno loro di generare versioni personalizzate del software nel repository, provare soluzioni differenti isolandole l&rsquo;una dall&rsquo;altra e cercare in maniera efficiente attraverso la cronologia delle revisioni le sorgenti di bug e regressioni nell&rsquo;ambiente del cliente, il tutto senza aver bisogno di collegarsi alla rete della vostra azienda.</para>
 
     </sect2>
   </sect1>
       <listitem><para id="x_a0">&Egrave; facile da personalizzare.</para></listitem>
     </itemizedlist>
 
-    <para id="x_a1">Se avete una vaga familiarità con i sistemi di controllo di revisione, dovreste essere in grado di cominciare a usare Mercurial in meno di cinque minuti. Anche se non è così, non vi ci vorrà più di qualche altro minuto. L'insieme di comandi e caratteristiche di Mercurial è generalmente uniforme e consistente, così potete tenere a mente poche regole generali piuttosto che una nutrita schiera di eccezioni.</para>
+    <para id="x_a1">Se avete una vaga familiarità con i sistemi di controllo di revisione, dovreste essere in grado di cominciare a usare Mercurial in meno di cinque minuti. Anche se non è così, non vi ci vorrà più di qualche altro minuto. L&rsquo;insieme di comandi e caratteristiche di Mercurial è generalmente uniforme e consistente, così potete tenere a mente poche regole generali piuttosto che una nutrita schiera di eccezioni.</para>
 
     <para id="x_a2">Potete cominciare a lavorare con Mercurial su un piccolo progetto in pochi minuti, creando nuove modifiche e rami di sviluppo, trasferendo cambiamenti sia localmente che attraverso la rete, sfruttando la velocità di tutte le operazioni di stato e cronologia. Mercurial cerca di essere agile e di non starvi tra i piedi combinando un basso costo cognitivo con operazioni estremamente veloci.</para>
 
-    <para id="x_a3">L'utilità di Mercurial non si limita ai piccoli progetti: è usato da progetti contenenti decine di migliaia di file e centinaia di megabyte di codice sorgente su cui collaborano centinaia di migliaia di sviluppatori.</para>
+    <para id="x_a3">L&rsquo;utilità di Mercurial non si limita ai piccoli progetti: è usato da progetti contenenti decine di migliaia di file e centinaia di megabyte di codice sorgente su cui collaborano centinaia di migliaia di sviluppatori.</para>
 
-    <para id="x_a4">Se le funzioni principali di Mercurial non sono sufficienti per voi, è facile aggiungerne di nuove. Mercurial è particolarmente adatto alla programmazione delle proprie operazioni, e il codice pulito della sua implementazione in Python facilita l'aggiunta di funzioni sotto forma di estensioni. Esistono già un certo numero di estensioni utili e popolari, che spaziano dal supporto all'identificazione dei bug fino al miglioramento delle prestazioni.</para>
+    <para id="x_a4">Se le funzioni principali di Mercurial non sono sufficienti per voi, è facile aggiungerne di nuove. Mercurial è particolarmente adatto alla programmazione delle proprie operazioni, e il codice pulito della sua implementazione in Python facilita l&rsquo;aggiunta di funzioni sotto forma di estensioni. Esistono già un certo numero di estensioni utili e popolari, che spaziano dal supporto all&rsquo;identificazione dei bug fino al miglioramento delle prestazioni.</para>
 
   </sect1>
   <sect1>
     <sect2>
       <title>Subversion</title>
 
-      <para id="x_a6">Subversion è un sistema di controllo di revisione piuttosto popolare, sviluppato per sostituire CVS. Ha un'architettura client/server centralizzata.</para>
+      <para id="x_a6">Subversion è un sistema di controllo di revisione piuttosto popolare, sviluppato per sostituire CVS. Ha un&rsquo;architettura client/server centralizzata.</para>
 
-      <para id="x_a7">Subversion e Mercurial hanno comandi con nomi simili per effettuare le stesse operazioni, così se avete familiarità con uno dei due è facile imparare a usare l'altro. Entrambi gli strumenti sono portabili su tutti i sistemi operativi più popolari.</para>
+      <para id="x_a7">Subversion e Mercurial hanno comandi con nomi simili per effettuare le stesse operazioni, così se avete familiarità con uno dei due è facile imparare a usare l&rsquo;altro. Entrambi gli strumenti sono portabili su tutti i sistemi operativi più popolari.</para>
 
       <para id="x_a8">Prima della versione 1.5, Subversion non aveva alcun supporto efficace per le unioni. Al momento della scrittura, la sua funzione per la gestione delle unioni è nuova e nota per essere <ulink
 	  url="http://svnbook.red-bean.com/nightly/en/svn.branchmerge.advanced.html#svn.branchmerge.advanced.finalword">complicata e difettosa</ulink>.</para>
 
       <para id="x_a9">Mercurial ha un sostanzioso vantaggio in termini di prestazioni rispetto a Subversion per tutte le operazioni di controllo di revisione di cui ho effettuato il benchmark. Il suo vantaggio si misura in un intervallo che va da un fattore due a un fattore sei quando lo si confronta con il modulo <emphasis>ra_local</emphasis> di Subversion 1.4.3, che lavora con repository locali ed è quindi il metodo di accesso più veloce disponibile. In situazioni più realistiche che coinvolgono un accesso al repository attraverso la rete, Subversion sconterà uno svantaggio sostanzialmente più consistente. Dato che molti comandi di Subversion devono comunicare con il server e Subversion non è dotato di meccanismi di replicazione efficaci, la capacità del server e la banda di rete diventano colli di bottiglia già per progetti di dimensioni moderate.</para>
 
-      <para id="x_aa">In più, Subversion si espone a un sostanziale utilizzo aggiuntivo di spazio su disco per evitare transazioni di rete durante l'esecuzione di alcune operazioni comuni, come trovare i file modificati (<literal>status</literal>) e visualizzare le modifiche rispetto alla revisione corrente (<literal>diff</literal>). Come risultato, la copia di lavoro di un repository Subversion è spesso delle stesse dimensioni, se non più grande, di un intero repository Mercurial più la sua directory di lavoro, anche nel caso in cui il repository Mercurial contenga la cronologia completa del progetto.</para>
+      <para id="x_aa">In più, Subversion si espone a un sostanziale utilizzo aggiuntivo di spazio su disco per evitare transazioni di rete durante l&rsquo;esecuzione di alcune operazioni comuni, come trovare i file modificati (<literal>status</literal>) e visualizzare le modifiche rispetto alla revisione corrente (<literal>diff</literal>). Come risultato, la copia di lavoro di un repository Subversion è spesso delle stesse dimensioni, se non più grande, di un intero repository Mercurial più la sua directory di lavoro, anche nel caso in cui il repository Mercurial contenga la cronologia completa del progetto.</para>
 
-      <para id="x_ab">Subversion è ampiamente supportato da strumenti di terze parti. Mercurial è considerevolmente indietro in quest'area. Il divario si sta assottigliando, tuttavia, e in effetti alcuni degli strumenti di interfaccia grafica di Mercurial attualmente offuscano i loro equivalenti per Subversion. Come Mercurial, Subversion è dotato di un eccellente manuale d'uso.</para>
+      <para id="x_ab">Subversion è ampiamente supportato da strumenti di terze parti. Mercurial è considerevolmente indietro in quest&rsquo;area. Il divario si sta assottigliando, tuttavia, e in effetti alcuni degli strumenti di interfaccia grafica di Mercurial attualmente offuscano i loro equivalenti per Subversion. Come Mercurial, Subversion è dotato di un eccellente manuale d&rsquo;uso.</para>
 
-      <para id="x_ac">Dato che Subversion non memorizza la cronologia di revisione sul client, è molto adatto a gestire progetti che hanno a che fare con numerosi file binari di grandi dimensioni. Se aggiungete cinquanta revisioni di un file incomprimibile di 10MB a un repository, l'utilizzo di spazio sul lato client da parte di Subversion rimarrà costante. Lo spazio usato da qualunque SCM distribuito crescerà rapidamente in proporzione al numero delle revisioni, perché le differenze tra una revisione e l'altra sono grandi.</para>
+      <para id="x_ac">Dato che Subversion non memorizza la cronologia di revisione sul client, è molto adatto a gestire progetti che hanno a che fare con numerosi file binari di grandi dimensioni. Se aggiungete cinquanta revisioni di un file incomprimibile di 10MB a un repository, l&rsquo;utilizzo di spazio sul lato client da parte di Subversion rimarrà costante. Lo spazio usato da qualunque SCM distribuito crescerà rapidamente in proporzione al numero delle revisioni, perché le differenze tra una revisione e l&rsquo;altra sono grandi.</para>
 
-      <para id="x_ad">In più, è spesso difficile, o più tipicamente impossibile, unire differenti versioni di un file binario. L'abilità di Subversion di permettere a un utente di bloccare un file, in modo da ottenere temporaneamente i diritti esclusivi per modificarlo, può essere un vantaggio significativo in progetti dove i file binari vengono largamente utilizzati.</para>
+      <para id="x_ad">In più, è spesso difficile, o più tipicamente impossibile, unire differenti versioni di un file binario. L&rsquo;abilità di Subversion di permettere a un utente di bloccare un file, in modo da ottenere temporaneamente i diritti esclusivi per modificarlo, può essere un vantaggio significativo in progetti dove i file binari vengono largamente utilizzati.</para>
 
-      <para id="x_ae">Mercurial può importare la cronologia delle revisioni da un repository Subversion. Può anche esportare la propria cronologia delle revisioni verso un repository Subversion. Questa caratteristica vi permette di <quote>sentire l'acqua</quote> utilizzando Mercurial e Subverison in parallelo prima di decidere di cambiare. La conversione della cronologia è incrementale, così potete effettuare una conversione iniziale, poi piccole conversioni aggiuntive per introdurre successivamente nuovi cambiamenti.</para>
+      <para id="x_ae">Mercurial può importare la cronologia delle revisioni da un repository Subversion. Può anche esportare la propria cronologia delle revisioni verso un repository Subversion. Questa caratteristica vi permette di <quote>sentire l&rsquo;acqua</quote> utilizzando Mercurial e Subverison in parallelo prima di decidere di cambiare. La conversione della cronologia è incrementale, così potete effettuare una conversione iniziale, poi piccole conversioni aggiuntive per introdurre successivamente nuovi cambiamenti.</para>
 
     </sect2>
     <sect2>
       <title>Git</title>
 
-      <para id="x_af">Git è uno strumento per il controllo di revisione distribuito che è stato sviluppato per gestire l'albero dei sorgenti del kernel di Linux. Come Mercurial, il suo design iniziale è stato in qualche modo influenzato da Monotone.</para>
+      <para id="x_af">Git è uno strumento per il controllo di revisione distribuito che è stato sviluppato per gestire l&rsquo;albero dei sorgenti del kernel di Linux. Come Mercurial, il suo design iniziale è stato in qualche modo influenzato da Monotone.</para>
 
       <para id="x_b0">Git possiede un insieme di comandi piuttosto ampio, con la versione 1.5.0 che fornisce 139 singoli comandi. Si è fatto una certa reputazione di essere difficile da imparare. Rispetto a Git, Mercurial pone una maggiore attenzione alla semplicità.</para>
 
       <para id="x_b1">In termini di prestazioni, Git è estremamente veloce. In molti casi, è più veloce di Mercurial, almeno sotto Linux, mentre Mercurial è più prestante per altre operazioni. Tuttavia, sotto Windows, le prestazioni e il livello generale di supporto offerto da Git sono, al momento della scrittura, molto più indietro rispetto a Mercurial.</para>
 
-      <para id="x_b2">Mentre un repository Mercurial non ha bisogno di alcuna manutenzione, un repository Git richiede frequenti <quote>reimpacchettamenti</quote> manuali dei propri metadati. Senza questi, le prestazioni degradano e l'utilizzo di spazio cresce rapidamente. Le prestazioni di un server che contiene molti repository Git che non vengono rigorosamente e frequentemente reimpacchettati diventeranno pesantemente legate all'utilizzo del disco durante i backup, risultando in istanze di backup giornalieri che impiegano molto più di 24 ore per terminare. Un repository Git appena impacchettato è leggermente più piccolo di un repository Mercurial, ma un repository non impacchettato ha dimensioni maggiori di diversi ordini di grandezza.</para>
+      <para id="x_b2">Mentre un repository Mercurial non ha bisogno di alcuna manutenzione, un repository Git richiede frequenti <quote>reimpacchettamenti</quote> manuali dei propri metadati. Senza questi, le prestazioni degradano e l&rsquo;utilizzo di spazio cresce rapidamente. Le prestazioni di un server che contiene molti repository Git che non vengono rigorosamente e frequentemente reimpacchettati diventeranno pesantemente legate all&rsquo;utilizzo del disco durante i backup, risultando in istanze di backup giornalieri che impiegano molto più di 24 ore per terminare. Un repository Git appena impacchettato è leggermente più piccolo di un repository Mercurial, ma un repository non impacchettato ha dimensioni maggiori di diversi ordini di grandezza.</para>
 
       <para id="x_b3">Il cuore di Git è scritto in C. Molti comandi di Git sono implementati come script di shell o in linguaggio Perl la cui qualità è notevolmente variabile. Ho incontrato diversi casi in cui gli script proseguivano ciecamente la propria esecuzione in presenza di errori che avrebbero dovuto essere fatali.</para>
 
 
       <para id="x_b5">CVS è probabilmente lo strumento di controllo di revisione più usato nel mondo. A causa della sua età e della sporcizia interna, è stato mantenuto solo superficialmente per diversi anni.</para>
 
-      <para id="x_b6">Ha un'architettura client/server centralizzata. Non raggruppa cambiamenti di file correlati in inserimenti atomici, esponendo gli utenti al rischio di <quote>guastare il software</quote>: una persona può inserire con successo parte di un cambiamento e poi essere bloccata dalla necessità di un'unione, vincolando altre persone a vedere solo una porzione del lavoro che intendeva fare. Questo influisce anche sul modo di lavorare con la cronologia del progetto. Se volete vedere tutte le modifiche che qualcuno ha effettuato come parte di un'attività, dovrete ispezionare manualmente le descrizioni e le marcature temporali dei cambiamenti fatti a ogni file coinvolto (sempre che sappiate quali fossero quei file).</para>
+      <para id="x_b6">Ha un&rsquo;architettura client/server centralizzata. Non raggruppa cambiamenti di file correlati in inserimenti atomici, esponendo gli utenti al rischio di <quote>guastare il software</quote>: una persona può inserire con successo parte di un cambiamento e poi essere bloccata dalla necessità di un&rsquo;unione, vincolando altre persone a vedere solo una porzione del lavoro che intendeva fare. Questo influisce anche sul modo di lavorare con la cronologia del progetto. Se volete vedere tutte le modifiche che qualcuno ha effettuato come parte di un&rsquo;attività, dovrete ispezionare manualmente le descrizioni e le marcature temporali dei cambiamenti fatti a ogni file coinvolto (sempre che sappiate quali fossero quei file).</para>
 
       <para id="x_b7">CVS ha una nozione confusa di etichette e rami di lavoro che non cercherò nemmeno di descrivere. Non gestisce per bene il cambiamento dei nomi di file o directory, esponendo il repository al rischio di danneggiamenti. Non ha quasi alcuna funzionalità per il controllo della consistenza interna, quindi tipicamente non è nemmeno possibile dire se un repository è danneggiato. Non raccomanderei CVS per nessun progetto, nuovo o esistente.</para>
 
-      <para id="x_b8">Mercurial può importare la cronologia di revisione da un repository CVS. Tuttavia, ci sono alcune avvertenze da considerare, valide anche per qualsiasi altro strumento di controllo di revisione che importi dati da CVS. A causa della mancanza di inserimenti atomici in CVS e della mancanza di versioni per la gerarchia dei file, non è possibile ricostruire la cronologia di CVS in maniera completa e accurata, bensì devono essere fatte alcune supposizioni, e le modifiche ai nomi dei file di solito non verranno mostrate. Dato che buona parte dell'amministrazione avanzata di CVS deve essere fatta a mano e quindi è soggetta a errori, i programmi che importano dati da CVS incorrono comunemente in molteplici problemi dovuti a repository danneggiati (marcature temporali completamente fasulle per le revisioni e file che sono rimasti bloccati per più di un decennio sono solo due dei problemi meno interessanti che posso ricordare dalla mia esperienza personale).</para>
+      <para id="x_b8">Mercurial può importare la cronologia di revisione da un repository CVS. Tuttavia, ci sono alcune avvertenze da considerare, valide anche per qualsiasi altro strumento di controllo di revisione che importi dati da CVS. A causa della mancanza di inserimenti atomici in CVS e della mancanza di versioni per la gerarchia dei file, non è possibile ricostruire la cronologia di CVS in maniera completa e accurata, bensì devono essere fatte alcune supposizioni, e le modifiche ai nomi dei file di solito non verranno mostrate. Dato che buona parte dell&rsquo;amministrazione avanzata di CVS deve essere fatta a mano e quindi è soggetta a errori, i programmi che importano dati da CVS incorrono comunemente in molteplici problemi dovuti a repository danneggiati (marcature temporali completamente fasulle per le revisioni e file che sono rimasti bloccati per più di un decennio sono solo due dei problemi meno interessanti che posso ricordare dalla mia esperienza personale).</para>
 <!--
       <para id="x_b9">Mercurial può importare la cronologia di revisione da un repository CVS.</para>
 -->
     <sect2>
       <title>Strumenti commerciali</title>
 
-      <para id="x_ba">Perforce ha un'architettura client/server centralizzata in cui nessun dato viene memorizzato sul lato client. A differenza degli strumenti di controllo di revisione moderni, Perforce richiede che l'utente esegua un comando per comunicare al server di voler modificare un qualsiasi file.</para>
+      <para id="x_ba">Perforce ha un&rsquo;architettura client/server centralizzata in cui nessun dato viene memorizzato sul lato client. A differenza degli strumenti di controllo di revisione moderni, Perforce richiede che l&rsquo;utente esegua un comando per comunicare al server di voler modificare un qualsiasi file.</para>
 
-      <para id="x_bb">Le prestazioni di Perforce sono piuttosto buone per piccoli gruppi di lavoro, ma decadono rapidamente man mano che il numero di utenti cresce oltre le poche dozzine. Installazioni di Perforce di modeste dimensioni richiedono l'utilizzo di proxy per fronteggiare il carico generato dai propri utenti.</para>
+      <para id="x_bb">Le prestazioni di Perforce sono piuttosto buone per piccoli gruppi di lavoro, ma decadono rapidamente man mano che il numero di utenti cresce oltre le poche dozzine. Installazioni di Perforce di modeste dimensioni richiedono l&rsquo;utilizzo di proxy per fronteggiare il carico generato dai propri utenti.</para>
 
     </sect2>
     <sect2>
       <title>Scegliere uno strumento di controllo di revisione</title>
 
-      <para id="x_bc">Con l'eccezione di CVS, tutti gli strumenti appena elencati hanno qualità uniche che li rendono adatti a particolari stili di lavoro. Non esiste un singolo strumento di controllo di revisione che sia il migliore in tutte le situazioni.</para>
+      <para id="x_bc">Con l&rsquo;eccezione di CVS, tutti gli strumenti appena elencati hanno qualità uniche che li rendono adatti a particolari stili di lavoro. Non esiste un singolo strumento di controllo di revisione che sia il migliore in tutte le situazioni.</para>
 
       <para id="x_bd">Per fare un esempio, Subversion è una buona scelta per chi lavora con file binari frequentemente modificati, a causa della sua natura centralizzata e del supporto per il bloccaggio dei file.</para>
 
   <sect1>
     <title>Passare da un altro strumento a Mercurial</title>
 
-    <para id="x_bf">Mercurial viene distribuito con un'estensione chiamata <literal role="hg-ext">convert</literal> che può importare in maniera incrementale la cronologia delle revisioni da diversi altri strumenti di controllo di revisione. Con <quote>incrementale</quote> voglio dire che potete convertire tutta la cronologia di un progetto in un'unica seduta, poi rieseguire la conversione più tardi per ottenere i nuovi cambiamenti che sono avvenuti dopo la conversione iniziale.</para>
+    <para id="x_bf">Mercurial viene distribuito con un&rsquo;estensione chiamata <literal role="hg-ext">convert</literal> che può importare in maniera incrementale la cronologia delle revisioni da diversi altri strumenti di controllo di revisione. Con <quote>incrementale</quote> voglio dire che potete convertire tutta la cronologia di un progetto in un&rsquo;unica seduta, poi rieseguire la conversione più tardi per ottenere i nuovi cambiamenti che sono avvenuti dopo la conversione iniziale.</para>
 
     <para id="x_c0">Gli strumenti di controllo di revisione supportati da <literal role="hg-ext">convert</literal> sono i seguenti:</para>
     <itemizedlist>
       <listitem><para id="x_c3">Git</para></listitem>
       <listitem><para id="x_c4">Darcs</para></listitem></itemizedlist>
 
-    <para id="x_c5">In più, <literal role="hg-ext">convert</literal> può esportare i cambiamenti da Mercurial a Subversion. Questo rende possibile provare Subversion e Mercurial in parallelo senza rischiare di perdere il proprio lavoro prima di impegnarsi nel definitivo passaggio dall'uno all'altro.</para>
+    <para id="x_c5">In più, <literal role="hg-ext">convert</literal> può esportare i cambiamenti da Mercurial a Subversion. Questo rende possibile provare Subversion e Mercurial in parallelo senza rischiare di perdere il proprio lavoro prima di impegnarsi nel definitivo passaggio dall&rsquo;uno all&rsquo;altro.</para>
 
-    <para id="x_c6">Il comando <command role="hg-ext-convert">convert</command> è facile da usare. Vi basta puntarlo al percorso o all'URL di un repository sorgente, dandogli opzionalmente il nome di un repository destinazione, e comincerà a lavorare. Dopo la conversione iniziale, sarà sufficiente eseguire ancora lo stesso comando per importare i nuovi cambiamenti.</para>
+    <para id="x_c6">Il comando <command role="hg-ext-convert">convert</command> è facile da usare. Vi basta puntarlo al percorso o all&rsquo;URL di un repository sorgente, dandogli opzionalmente il nome di un repository destinazione, e comincerà a lavorare. Dopo la conversione iniziale, sarà sufficiente eseguire ancora lo stesso comando per importare i nuovi cambiamenti.</para>
   </sect1>
 
   <sect1>
     <title>Una breve storia del controllo di revisione</title>
 
-    <para id="x_c7">Il più noto tra i vecchi strumenti per il controllo di revisione è SCCS (acronimo di Source Code Control System, sistema per il controllo del codice sorgente), che Marc Rochkind scrisse mentre lavorava ai laboratori Bell nei primi anni '70. SCCS operava su singoli file e obbligava ogni persona che lavorasse su un progetto ad avere accesso a uno spazio di lavoro condiviso su un singolo sistema. Solo una persona alla volta poteva modificare un file e l'arbitraggio per l'accesso ai file era realizzato attraverso i blocchi (in inglese, lock). Capitava spesso che le persone bloccassero i file e si dimenticassero di sbloccarli più tardi, impedendo a chiunque altro di modificare quei file senza l'aiuto di un amministratore.</para>
+    <para id="x_c7">Il più noto tra i vecchi strumenti per il controllo di revisione è SCCS (acronimo di Source Code Control System, sistema per il controllo del codice sorgente), che Marc Rochkind scrisse mentre lavorava ai laboratori Bell nei primi anni &rsquo;70. SCCS operava su singoli file e obbligava ogni persona che lavorasse su un progetto ad avere accesso a uno spazio di lavoro condiviso su un singolo sistema. Solo una persona alla volta poteva modificare un file e l&rsquo;arbitraggio per l&rsquo;accesso ai file era realizzato attraverso i blocchi (in inglese, lock). Capitava spesso che le persone bloccassero i file e si dimenticassero di sbloccarli più tardi, impedendo a chiunque altro di modificare quei file senza l&rsquo;aiuto di un amministratore.</para>
 
-    <para id="x_c8">Walter Tichy sviluppò un'alternativa libera a SCCS nei primi anni '80, chiamando il suo programma RCS (acronimo di Revision Control System, sistema per il controllo di revisione). Come SCCS, RCS obbligava gli sviluppatori a lavorare in un singolo spazio di lavoro condiviso e a bloccare i file per prevenire cambiamenti simultanei da parte di più persone.</para>
+    <para id="x_c8">Walter Tichy sviluppò un&rsquo;alternativa libera a SCCS nei primi anni &rsquo;80, chiamando il suo programma RCS (acronimo di Revision Control System, sistema per il controllo di revisione). Come SCCS, RCS obbligava gli sviluppatori a lavorare in un singolo spazio di lavoro condiviso e a bloccare i file per prevenire cambiamenti simultanei da parte di più persone.</para>
 
-    <para id="x_c9">Più tardi nel corso degli anni '80, Dick Grune usò RCS come componente di base per un insieme di script di shell che chiamò inizialmente cmt, ma che poi ribattezzò CVS (acronimo di Concurrent Versions System, sistema di versioni concorrenti). La grande innovazione di CVS fu che permetteva agli sviluppatori di lavorare simultaneamente e in qualche modo indipendentemente nel loro spazio di lavoro personale. Gli spazi di lavoro personali evitavano agli sviluppatori di pestarsi i piedi tutte le volte, come capitava comunemente con SCCS e RCS. Ogni sviluppatore aveva la copia di ogni file contenuto nel progetto e poteva modificare le proprie copie indipendentemente. Era necessario combinare le singole modifiche prima di introdurre i cambiamenti nel repository centrale.</para>
+    <para id="x_c9">Più tardi nel corso degli anni &rsquo;80, Dick Grune usò RCS come componente di base per un insieme di script di shell che chiamò inizialmente cmt, ma che poi ribattezzò CVS (acronimo di Concurrent Versions System, sistema di versioni concorrenti). La grande innovazione di CVS fu che permetteva agli sviluppatori di lavorare simultaneamente e in qualche modo indipendentemente nel loro spazio di lavoro personale. Gli spazi di lavoro personali evitavano agli sviluppatori di pestarsi i piedi tutte le volte, come capitava comunemente con SCCS e RCS. Ogni sviluppatore aveva la copia di ogni file contenuto nel progetto e poteva modificare le proprie copie indipendentemente. Era necessario combinare le singole modifiche prima di introdurre i cambiamenti nel repository centrale.</para>
 
-    <para id="x_ca">Brian Berliner prese gli script originali di Grune e li riscrisse in C, rilasciando nel 1989 il codice che fin da allora è stato sviluppato come la moderna versione di CVS. CVS successivamente acquisì l'abilità di operare attraverso una connessione di rete, caratteristica che gli conferì la propria architettura client/server. L'architettura di CVS è centralizzata: solo il server ha la copia della cronologia del progetto, mentre gli spazi di lavoro sui client contengono solamente una copia delle versioni recenti dei file del progetto e i metadati che servono per conoscere l'ubicazione del server. CVS ha avuto un enorme successo e probabilmente è il sistema di controllo di revisione più diffuso al mondo.</para>
+    <para id="x_ca">Brian Berliner prese gli script originali di Grune e li riscrisse in C, rilasciando nel 1989 il codice che fin da allora è stato sviluppato come la moderna versione di CVS. CVS successivamente acquisì l&rsquo;abilità di operare attraverso una connessione di rete, caratteristica che gli conferì la propria architettura client/server. L&rsquo;architettura di CVS è centralizzata: solo il server ha la copia della cronologia del progetto, mentre gli spazi di lavoro sui client contengono solamente una copia delle versioni recenti dei file del progetto e i metadati che servono per conoscere l&rsquo;ubicazione del server. CVS ha avuto un enorme successo e probabilmente è il sistema di controllo di revisione più diffuso al mondo.</para>
 
-    <para id="x_cb">All'inizio degli anni '90, Sun Microsystems sviluppò un primo sistema per il controllo di revisione distribuito chiamato TeamWare. Uno spazio di lavoro in TeamWare contiene una copia completa della cronologia del progetto. TeamWare non possiede alcuna nozione di un repository centrale. (CVS si basava su RCS per la memorizzazione della cronologia, TeamWare usava SCCS.)</para>
+    <para id="x_cb">All&rsquo;inizio degli anni &rsquo;90, Sun Microsystems sviluppò un primo sistema per il controllo di revisione distribuito chiamato TeamWare. Uno spazio di lavoro in TeamWare contiene una copia completa della cronologia del progetto. TeamWare non possiede alcuna nozione di un repository centrale. (CVS si basava su RCS per la memorizzazione della cronologia, TeamWare usava SCCS.)</para>
 
-    <para id="x_cc">Durante gli anni '90 crebbe la consapevolezza dei numerosi problemi di CVS. CVS registra individualmente cambiamenti simultanei a più di un file, invece di raggrupparli insieme come una singola operazione logicamente atomica, inoltre non gestisce bene la propria gerarchia di file, ed è facile danneggiare un repository cambiando i nomi di file e directory. Le difficoltà di lettura e manutenzione del suo codice sorgente resero proibitiva la <quote>soglia del dolore</quote> da oltrepassare per correggere questi problemi architetturali.</para>
+    <para id="x_cc">Durante gli anni &rsquo;90 crebbe la consapevolezza dei numerosi problemi di CVS. CVS registra individualmente cambiamenti simultanei a più di un file, invece di raggrupparli insieme come una singola operazione logicamente atomica, inoltre non gestisce bene la propria gerarchia di file, ed è facile danneggiare un repository cambiando i nomi di file e directory. Le difficoltà di lettura e manutenzione del suo codice sorgente resero proibitiva la <quote>soglia del dolore</quote> da oltrepassare per correggere questi problemi architetturali.</para>
 
-    <para id="x_cd">Nel 2001, Jim Blandy e Karl Fogel, due sviluppatori che avevano lavorato su CVS, diedero vita a un progetto per sostituirlo con uno strumento che avrebbe avuto un'architettura migliore e un codice più pulito. Il risultato, Subversion, non si allontana dal modello client/server centralizzato di CVS, ma aggiunge inserimenti atomici per più file alla volta, una miglior gestione degli spazi di nomi e un certo numero di altre caratteristiche che lo rendono uno strumento generalmente migliore di CVS. Dal suo rilascio iniziale, la sua popolarità è rapidamente cresciuta.</para>
+    <para id="x_cd">Nel 2001, Jim Blandy e Karl Fogel, due sviluppatori che avevano lavorato su CVS, diedero vita a un progetto per sostituirlo con uno strumento che avrebbe avuto un&rsquo;architettura migliore e un codice più pulito. Il risultato, Subversion, non si allontana dal modello client/server centralizzato di CVS, ma aggiunge inserimenti atomici per più file alla volta, una miglior gestione degli spazi di nomi e un certo numero di altre caratteristiche che lo rendono uno strumento generalmente migliore di CVS. Dal suo rilascio iniziale, la sua popolarità è rapidamente cresciuta.</para>
 
-    <para id="x_ce">Più o meno simultaneamente, Graydon Hoare cominciò a lavorare su un ambizioso sistema distribuito di controllo di revisione che chiamò Monotone. Monotone non si limita a risolvere molti dei problemi di progettazione di CVS e a possedere un'architettura peer-to-peer, ma va oltre i primi (e i successivi) strumenti di controllo di revisione in un certo numero di modi innovativi, usando hash crittografici come identificatori e adottando una nozione integrale di <quote>fiducia</quote> per autenticare il codice che proviene da sorgenti differenti.</para>
+    <para id="x_ce">Più o meno simultaneamente, Graydon Hoare cominciò a lavorare su un ambizioso sistema distribuito di controllo di revisione che chiamò Monotone. Monotone non si limita a risolvere molti dei problemi di progettazione di CVS e a possedere un&rsquo;architettura peer-to-peer, ma va oltre i primi (e i successivi) strumenti di controllo di revisione in un certo numero di modi innovativi, usando hash crittografici come identificatori e adottando una nozione integrale di <quote>fiducia</quote> per autenticare il codice che proviene da sorgenti differenti.</para>
 
-    <para id="x_cf">Mercurial nacque nel 2005. Mentre alcuni aspetti della sua progettazione sono stati influenzati da Monotone, Mercurial si concentra su facilità d'uso, prestazioni elevate e scalabilità verso progetti molto grandi.</para>
+    <para id="x_cf">Mercurial nacque nel 2005. Mentre alcuni aspetti della sua progettazione sono stati influenzati da Monotone, Mercurial si concentra su facilità d&rsquo;uso, prestazioni elevate e scalabilità verso progetti molto grandi.</para>
   </sect1>
 </chapter>

it/ch02-tour-basic.xml

     <sect2>
       <title>Windows</title>
 
-      <para id="x_c">La miglior versione di Mercurial per Windows è TortoiseHg, che può essere trovata all'indirizzo <ulink url="http://bitbucket.org/tortoisehg/stable/wiki/Home">http://bitbucket.org/tortoisehg/stable/wiki/Home</ulink>. Questo pacchetto non ha dipendenze esterne ed è pronto a funzionare non appena viene installato. Fornisce sia un'interfaccia a linea di comando sia un'interfaccia grafica.</para>
+      <para id="x_c">La miglior versione di Mercurial per Windows è TortoiseHg, che può essere trovata all&rsquo;indirizzo <ulink url="http://bitbucket.org/tortoisehg/stable/wiki/Home">http://bitbucket.org/tortoisehg/stable/wiki/Home</ulink>. Questo pacchetto non ha dipendenze esterne ed è pronto a funzionare non appena viene installato. Fornisce sia un&rsquo;interfaccia a linea di comando sia un&rsquo;interfaccia grafica.</para>
 
     </sect2>
 
     <sect2>
       <title>Mac OS X</title>
 
-      <para id="x_a">Lee Cantey fornisce un pacchetto di installazione di Mercurial per Mac OS X all'indirizzo <ulink url="http://mercurial.berkwood.com">http://mercurial.berkwood.com</ulink>.</para>
+      <para id="x_a">Lee Cantey fornisce un pacchetto di installazione di Mercurial per Mac OS X all&rsquo;indirizzo <ulink url="http://mercurial.berkwood.com">http://mercurial.berkwood.com</ulink>.</para>
     </sect2>
 
     <sect2>
 
       <para id="x_2">Dato che ogni distribuzione Linux ha i propri stumenti di impacchettamento, le proprie politiche e il proprio ritmo di sviluppo, è difficile dare un insieme completo di istruzioni su come installare i pacchetti eseguibili di Mercurial. La versione di Mercurial che finirete per ottenere può variare a seconda di quanto sia attiva la persona che mantiene il pacchetto di installazione per la vostra distribuzione.</para>
 
-      <para id="x_3">Per semplificare le cose, mi concentrerò sull'installazione di Mercurial dalla linea di comando sulle distribuzioni Linux più popolari. La maggior parte di queste distribuzioni fornisce un gestore grafico per i pacchetti di installazione che vi permetterà di installare Mercurial con un singolo click sulla voce relativa al pacchetto chiamato <literal>mercurial</literal>.</para>
+      <para id="x_3">Per semplificare le cose, mi concentrerò sull&rsquo;installazione di Mercurial dalla linea di comando sulle distribuzioni Linux più popolari. La maggior parte di queste distribuzioni fornisce un gestore grafico per i pacchetti di installazione che vi permetterà di installare Mercurial con un singolo click sulla voce relativa al pacchetto chiamato <literal>mercurial</literal>.</para>
 
       <itemizedlist>
 	<listitem><para id="x_4">Ubuntu e Debian:</para>
     <sect2>
       <title>Solaris</title>
 
-      <para id="x_9">SunFreeWare, all'indirizzo <ulink url="http://www.sunfreeware.com">http://www.sunfreeware.com</ulink>, allestisce pacchetti precompilati di Mercurial.</para>
+      <para id="x_9">SunFreeWare, all&rsquo;indirizzo <ulink url="http://www.sunfreeware.com">http://www.sunfreeware.com</ulink>, allestisce pacchetti precompilati di Mercurial.</para>
 
     </sect2>
 
   <sect1>
     <title>Per cominciare</title>
 
-    <para id="x_e">Come prima cosa, useremo il comando <command role="hg-cmd">hg version</command> per verificare che Mercurial sia correttamente installato. L'effettiva informazione sulla versione stampata dal comando non è così importante, in quanto ci interessa semplicemente che il comando venga eseguito e che stampi qualche cosa.</para>
+    <para id="x_e">Come prima cosa, useremo il comando <command role="hg-cmd">hg version</command> per verificare che Mercurial sia correttamente installato. L&rsquo;effettiva informazione sulla versione stampata dal comando non è così importante, in quanto ci interessa semplicemente che il comando venga eseguito e che stampi qualche cosa.</para>
 
     &interaction.tour.version;
 
     <sect2>
       <title>Aiuto predefinito</title>
 
-      <para id="x_f">Mercurial include un sistema di aiuto predefinito che si rivela inestimabile quando vi trovate bloccati cercando di ricordare come si esegue un comando. Se siete completamente bloccati, provate a invocare <command role="hg-cmd">hg help</command> per visualizzare una breve lista di comandi insieme a una descrizione delle funzionalità di ognuno. Se chiedete aiuto per un comando specifico (come nell'esempio seguente), verranno stampate informazioni più dettagliate.</para>
+      <para id="x_f">Mercurial include un sistema di aiuto predefinito che si rivela inestimabile quando vi trovate bloccati cercando di ricordare come si esegue un comando. Se siete completamente bloccati, provate a invocare <command role="hg-cmd">hg help</command> per visualizzare una breve lista di comandi insieme a una descrizione delle funzionalità di ognuno. Se chiedete aiuto per un comando specifico (come nell&rsquo;esempio seguente), verranno stampate informazioni più dettagliate.</para>
 
 	&interaction.tour.help;
 
-	<para id="x_10">Per ottenere un livello di dettaglio ancora maggiore (che di solito non vi servirà) eseguite <command role="hg-cmd">hg help <option role="hg-opt-global">-v</option></command>. L'opzione <option role="hg-opt-global">-v</option> è l'abbreviazione di <option role="hg-opt-global">--verbose</option> e dice a Mercurial di stampare più informazioni di quanto farebbe di solito.</para>
+	<para id="x_10">Per ottenere un livello di dettaglio ancora maggiore (che di solito non vi servirà) eseguite <command role="hg-cmd">hg help <option role="hg-opt-global">-v</option></command>. L&rsquo;opzione <option role="hg-opt-global">-v</option> è l&rsquo;abbreviazione di <option role="hg-opt-global">--verbose</option> e dice a Mercurial di stampare più informazioni di quanto farebbe di solito.</para>
 
     </sect2>
   </sect1>
   <sect1>
     <title>Lavorare con un repository</title>
 
-    <para id="x_11">In Mercurial, tutto accade all'interno di un <emphasis>repository</emphasis>. Il repository di un progetto contiene tutti i file che <quote>appartengono</quote> a quel progetto insieme a una registrazione cronologica delle loro modifiche.</para>
+    <para id="x_11">In Mercurial, tutto accade all&rsquo;interno di un <emphasis>repository</emphasis>. Il repository di un progetto contiene tutti i file che <quote>appartengono</quote> a quel progetto insieme a una registrazione cronologica delle loro modifiche.</para>
 
-    <para id="x_12">Non c'è niente di particolarmente magico in un repository: è semplicemente un albero di directory nel vostro file system che Mercurial tratta in modo speciale. Potete cancellare un repository o modificarne il nome in ogni momento, usando sia la riga di comando sia il vostro programma preferito di gestione dei file.</para>
+    <para id="x_12">Non c&rsquo;è niente di particolarmente magico in un repository: è semplicemente un albero di directory nel vostro file system che Mercurial tratta in modo speciale. Potete cancellare un repository o modificarne il nome in ogni momento, usando sia la riga di comando sia il vostro programma preferito di gestione dei file.</para>
 
     <sect2>
       <title>Fare una copia locale di un repository</title>
 
-      <para id="x_13"><emphasis>Copiare</emphasis> un repository è in realtà un'operazione un po' speciale. Pur potendo usare un normale comando di copia dei file per copiare un repository, il modo migliore per farlo è quello di usare un comando predefinito fornito da Mercurial. Questo comando si chiama <command role="hg-cmd">hg clone</command>, perché crea una copia identica di un repository esistente.</para>
+      <para id="x_13"><emphasis>Copiare</emphasis> un repository è in realtà un&rsquo;operazione un po&rsquo; speciale. Pur potendo usare un normale comando di copia dei file per copiare un repository, il modo migliore per farlo è quello di usare un comando predefinito fornito da Mercurial. Questo comando si chiama <command role="hg-cmd">hg clone</command>, perché crea una copia identica di un repository esistente.</para>
 
       &interaction.tour.clone;
 
 
       <para id="x_15">Il contenuto e la cronologia di questi file nel nostro repository sono gli stessi di quelli presenti nel repository che abbiamo clonato.</para>
 
-      <para id="x_16">Ogni repository Mercurial contiene la propria copia privata dei file e della cronologia di un progetto ed è sempre completo, auto-contenuto e indipendente. Come abbiamo appena detto, il clone di un repository ricorda l'ubicazione del repository da cui è stato clonato, ma Mercurial non comunicherà con quel repository, o con qualsiasi altro repository, a meno che non siamo noi a chiederlo.</para>
+      <para id="x_16">Ogni repository Mercurial contiene la propria copia privata dei file e della cronologia di un progetto ed è sempre completo, auto-contenuto e indipendente. Come abbiamo appena detto, il clone di un repository ricorda l&rsquo;ubicazione del repository da cui è stato clonato, ma Mercurial non comunicherà con quel repository, o con qualsiasi altro repository, a meno che non siamo noi a chiederlo.</para>
 
       <para id="x_17">Per ora, questo significa che siamo liberi di effettuare esperimenti con il nostro repository, sapendo con sicurezza che è un <quote>ambiente di prova</quote> privato le cui variazioni non avranno effetto su nessun altro.</para>
 
     <sect2>
       <title>Che cosa contiene un repository?</title>
 
-      <para id="x_18">Se diamo un'occhiata più dettagliata all'interno di un repository, possiamo vedere che contiene una directory chiamata <filename class="directory">.hg</filename>. Questo è il luogo dove Mercurial tiene tutti i propri metadati sul repository.</para>
+      <para id="x_18">Se diamo un&rsquo;occhiata più dettagliata all&rsquo;interno di un repository, possiamo vedere che contiene una directory chiamata <filename class="directory">.hg</filename>. Questo è il luogo dove Mercurial tiene tutti i propri metadati sul repository.</para>
 
       &interaction.tour.ls-a;
 
       <para id="x_19">Il contenuto della directory <filename class="directory">.hg</filename> e delle sue sottodirectory è riservato a Mercurial. Tutti gli altri file e directory nel repository sono vostri e potete farne ciò che volete.</para>
 
-      <para id="x_1a">Per introdurre un po' di terminologia, diciamo che la directory <filename class="directory">.hg</filename> è il repository <quote>reale</quote> e che tutti gli altri file e directory che coesistono con esso si trovano nella <emphasis>directory di lavoro</emphasis>. Potete ricordare facilmente questa distinzione se considerate che il <emphasis>repository</emphasis> contiene la <emphasis>cronologia</emphasis> del progetto, mentre la <emphasis>directory di lavoro</emphasis> contiene una <emphasis>fotografia</emphasis> del vostro progetto in un punto particolare della cronologia.</para>
+      <para id="x_1a">Per introdurre un po&rsquo; di terminologia, diciamo che la directory <filename class="directory">.hg</filename> è il repository <quote>reale</quote> e che tutti gli altri file e directory che coesistono con esso si trovano nella <emphasis>directory di lavoro</emphasis>. Potete ricordare facilmente questa distinzione se considerate che il <emphasis>repository</emphasis> contiene la <emphasis>cronologia</emphasis> del progetto, mentre la <emphasis>directory di lavoro</emphasis> contiene una <emphasis>fotografia</emphasis> del vostro progetto in un punto particolare della cronologia.</para>
 
     </sect2>
   </sect1>
     <itemizedlist>
       <listitem><para id="x_1e"><literal>changeset</literal>: questo campo ha il formato di un numero, seguito dal carattere di due punti, seguito da una stringa esadecimale. Questi sono gli <emphasis>identificatori</emphasis> del changeset. La stringa esadecimale è un identificatore unico: la stessa stringa esadecimale si riferirà sempre allo stesso changeset in ogni copia di questo repository. Il numero è più corto e facile da digitare rispetto alla stringa esadecimale, ma non è unico: lo stesso numero potrebbe identificare changeset differenti in due cloni differenti di uno stesso repository.</para>
       </listitem>
-      <listitem><para id="x_1f"><literal>utente</literal> (in inglese, <literal>user</literal>): l'identità della persona che ha creato il changeset. Questo è un campo di testo libero, ma il più delle volte contiene il nome e l'indirizzo email di una persona.</para></listitem>
-      <listitem><para id="x_20"><literal>data</literal> (in inglese, <literal>date</literal>): la data, l'orario e il fuso orario in cui il changeset è stato creato. (La data e l'orario sono locali per quel fuso orario e mostrano il giorno e l'ora per la persona che ha creato il changeset.)</para></listitem>
+      <listitem><para id="x_1f"><literal>utente</literal> (in inglese, <literal>user</literal>): l&rsquo;identità della persona che ha creato il changeset. Questo è un campo di testo libero, ma il più delle volte contiene il nome e l&rsquo;indirizzo email di una persona.</para></listitem>
+      <listitem><para id="x_20"><literal>data</literal> (in inglese, <literal>date</literal>): la data, l&rsquo;orario e il fuso orario in cui il changeset è stato creato. (La data e l&rsquo;orario sono locali per quel fuso orario e mostrano il giorno e l&rsquo;ora per la persona che ha creato il changeset.)</para></listitem>
       <listitem><para id="x_21"><literal>sommario</literal> (in inglese, <literal>summary</literal>): la prima riga del messaggio di testo che il creatore del changeset ha utilizzato per descrivere il changeset.</para></listitem>
       <listitem>
-	<para id="x_67d">Alcuni changeset, come il primo della lista mostrata qui sopra, sono contrassegnati da un'etichetta contenuta in un campo <literal>etichetta</literal> (in inglese, <literal>tag</literal>). Un'etichetta è un altro modo di identificare un changeset, dandogli un nome facile da ricordare. (L'etichetta chiamata <literal>tip</literal> è speciale: si riferisce sempre alla modifica più recente nel repository.)</para>
+	<para id="x_67d">Alcuni changeset, come il primo della lista mostrata qui sopra, sono contrassegnati da un&rsquo;etichetta contenuta in un campo <literal>etichetta</literal> (in inglese, <literal>tag</literal>). Un&rsquo;etichetta è un altro modo di identificare un changeset, dandogli un nome facile da ricordare. (L&rsquo;etichetta chiamata <literal>tip</literal> è speciale: si riferisce sempre alla modifica più recente nel repository.)</para>
       </listitem>
     </itemizedlist>
 
-    <para id="x_22">Il testo stampato dall'esecuzione predefinita del comando <command role="hg-cmd">hg log</command> è un semplice riepilogo e in quanto tale non contiene molti dettagli.</para>
+    <para id="x_22">Il testo stampato dall&rsquo;esecuzione predefinita del comando <command role="hg-cmd">hg log</command> è un semplice riepilogo e in quanto tale non contiene molti dettagli.</para>
 
-    <para id="x_23">La <xref linkend="fig:tour-basic:history"/> mostra una rappresentazione grafica della cronologia del repository <filename class="directory">hello</filename>, in modo che sia un po' più facile vedere qual è la direzione in cui la cronologia si sta <quote>sviluppando</quote>. Ritorneremo a questa figura diverse volte in questo capitolo e nei capitoli che seguono.</para>
+    <para id="x_23">La <xref linkend="fig:tour-basic:history"/> mostra una rappresentazione grafica della cronologia del repository <filename class="directory">hello</filename>, in modo che sia un po&rsquo; più facile vedere qual è la direzione in cui la cronologia si sta <quote>sviluppando</quote>. Ritorneremo a questa figura diverse volte in questo capitolo e nei capitoli che seguono.</para>
 
     <figure id="fig:tour-basic:history">
       <title>Rappresentazione grafica della cronologia per il repository <filename class="directory">hello</filename></title>
     <sect2>
       <title>Parlare di changeset o revisioni con altre persone</title>
 
-      <para id="x_25">Dato che l'inglese è una lingua notoriamente trasandata e che l'informatica ha una storia consacrata alla confusione terminologica (perché usare un solo termine quando se ne possono usare quattro?), il controllo di revisione impiega una varietà di termini ed espressioni per indicare la stessa cosa. Se parlate della cronologia di Mercurial con altre persone, scoprirete che il termine <quote>changeset</quote> è spesso abbreviato in <quote>change</quote> (in italiano, cambiamento) o in <quote>cset</quote> (nella sua forma scritta) e che talvolta ci si riferisce a un changeset chiamandolo <quote>revisione</quote> oppure <quote>rev</quote>.</para>
+      <para id="x_25">Dato che l&rsquo;inglese è una lingua notoriamente trasandata e che l&rsquo;informatica ha una storia consacrata alla confusione terminologica (perché usare un solo termine quando se ne possono usare quattro?), il controllo di revisione impiega una varietà di termini ed espressioni per indicare la stessa cosa. Se parlate della cronologia di Mercurial con altre persone, scoprirete che il termine <quote>changeset</quote> è spesso abbreviato in <quote>change</quote> (in italiano, cambiamento) o in <quote>cset</quote> (nella sua forma scritta) e che talvolta ci si riferisce a un changeset chiamandolo <quote>revisione</quote> oppure <quote>rev</quote>.</para>
 
-      <para id="x_26">Mentre non ha importanza quale <emphasis>parola</emphasis> voi usiate per riferirvi al concetto di <quote>un changeset</quote>, l'<emphasis>identificatore</emphasis> che usate per riferirvi a <quote>uno <emphasis>specifico</emphasis> changeset</quote> è di grande importanza. Ricordatevi che il campo <literal>changeset</literal> nel riepilogo mostrato da <command role="hg-cmd">hg log</command> identifica un changeset utilizzando sia un numero che una stringa esadecimale.</para>
+      <para id="x_26">Mentre non ha importanza quale <emphasis>parola</emphasis> voi usiate per riferirvi al concetto di <quote>un changeset</quote>, l&rsquo;<emphasis>identificatore</emphasis> che usate per riferirvi a <quote>uno <emphasis>specifico</emphasis> changeset</quote> è di grande importanza. Ricordatevi che il campo <literal>changeset</literal> nel riepilogo mostrato da <command role="hg-cmd">hg log</command> identifica un changeset utilizzando sia un numero che una stringa esadecimale.</para>
       <itemizedlist>
 	<listitem><para id="x_27">Il numero di revisione è una notazione comoda che è <emphasis>valida solo in quel repository</emphasis>.</para></listitem>
-	<listitem><para id="x_28">La stringa esadecimale è l'<emphasis>identificatore permanente e non modificabile</emphasis> che individuerà sempre quell'esatto changeset in <emphasis>qualsiasi</emphasis> copia del repository.</para></listitem>
+	<listitem><para id="x_28">La stringa esadecimale è l&rsquo;<emphasis>identificatore permanente e non modificabile</emphasis> che individuerà sempre quell&rsquo;esatto changeset in <emphasis>qualsiasi</emphasis> copia del repository.</para></listitem>
       </itemizedlist>
 
-      <para id="x_29">Questa distinzione è importante. Se spedite un'email a qualcuno parlando della <quote>revisione 33</quote>, c'è un'alta probabilità che la sua revisione 33 <emphasis>non sia la stessa</emphasis> della vostra, perché un numero di revisione dipende dall'ordine in cui i cambiamenti sono stati introdotti in un repository e non c'è alcuna garanzia che gli stessi cambiamenti siano avvenuti nello stesso ordine in repository differenti. Tre cambiamenti <literal>a,b,c</literal> possono facilmente comparire in un repository come <literal>0,1,2</literal> e in un altro repository come <literal>0,2,1</literal>.</para>
+      <para id="x_29">Questa distinzione è importante. Se spedite un&rsquo;email a qualcuno parlando della <quote>revisione 33</quote>, c&rsquo;è un&rsquo;alta probabilità che la sua revisione 33 <emphasis>non sia la stessa</emphasis> della vostra, perché un numero di revisione dipende dall&rsquo;ordine in cui i cambiamenti sono stati introdotti in un repository e non c&rsquo;è alcuna garanzia che gli stessi cambiamenti siano avvenuti nello stesso ordine in repository differenti. Tre cambiamenti <literal>a,b,c</literal> possono facilmente comparire in un repository come <literal>0,1,2</literal> e in un altro repository come <literal>0,2,1</literal>.</para>
 
-      <para id="x_2a">Mercurial usa i numeri di revisione soltanto come un'abbreviazione di convenienza. Se avete bisogno di discutere un changeset con qualcuno o di indicare un changeset per qualche altra ragione (per esempio, nella segnalazione di un bug), usate l'identificatore esadecimale.</para>
+      <para id="x_2a">Mercurial usa i numeri di revisione soltanto come un&rsquo;abbreviazione di convenienza. Se avete bisogno di discutere un changeset con qualcuno o di indicare un changeset per qualche altra ragione (per esempio, nella segnalazione di un bug), usate l&rsquo;identificatore esadecimale.</para>
 
     </sect2>
     <sect2>
       <title>Vedere revisioni specifiche</title>
 
-      <para id="x_2b">Per ridurre l'elenco stampato dal comando <command role="hg-cmd">hg log</command> a una singola revisione, usate l'opzione <option role="hg-opt-log">-r</option> (o <option role="hg-opt-log">--rev</option>). Potete usare sia un numero di revisione che un identificatore esadecimale e potete fornire al comando tutte le revisioni che volete.</para>
+      <para id="x_2b">Per ridurre l&rsquo;elenco stampato dal comando <command role="hg-cmd">hg log</command> a una singola revisione, usate l&rsquo;opzione <option role="hg-opt-log">-r</option> (o <option role="hg-opt-log">--rev</option>). Potete usare sia un numero di revisione che un identificatore esadecimale e potete fornire al comando tutte le revisioni che volete.</para>
 
       &interaction.tour.log-r;
 
-      <para id="x_2c">Se volete vedere la cronologia di diverse revisioni senza doverle elencare tutte potete usare la <emphasis>notazione di intervallo</emphasis>, che vi permette di esprimere l'idea di operare su <quote>tutte le revisioni tra <literal>abc</literal> e <literal>def</literal> comprese</quote>.</para>
+      <para id="x_2c">Se volete vedere la cronologia di diverse revisioni senza doverle elencare tutte potete usare la <emphasis>notazione di intervallo</emphasis>, che vi permette di esprimere l&rsquo;idea di operare su <quote>tutte le revisioni tra <literal>abc</literal> e <literal>def</literal> comprese</quote>.</para>
 
       &interaction.tour.log.range;
 
-      <para id="x_2d">Mercurial rispetta anche l'ordine in cui specificate le revisioni, quindi il comando <command role="hg-cmd">hg log -r 2:4</command> stamperà le revisioni 2, 3 e 4, mentre il comando <command role="hg-cmd">hg log -r 4:2</command> stamperà le revisioni 4, 3 e 2.</para>
+      <para id="x_2d">Mercurial rispetta anche l&rsquo;ordine in cui specificate le revisioni, quindi il comando <command role="hg-cmd">hg log -r 2:4</command> stamperà le revisioni 2, 3 e 4, mentre il comando <command role="hg-cmd">hg log -r 4:2</command> stamperà le revisioni 4, 3 e 2.</para>
 
     </sect2>
     <sect2>
       <title>Informazioni più dettagliate</title>
 
-      <para id="x_2e">Mentre le informazioni di riepilogo stampate da <command role="hg-cmd">hg log</command> sono utili se sapete già cosa state cercando, potreste aver bisogno di vedere una descrizione completa del cambiamento, o una lista dei file modificati, nel caso stiate tentando di capire se il changeset è quello che volevate. L'opzione <option role="hg-opt-global">-v</option> (o <option role="hg-opt-global">--verbose</option>) del comando <command role="hg-cmd">hg log</command> vi fornisce questi dettagli aggiuntivi.</para>
+      <para id="x_2e">Mentre le informazioni di riepilogo stampate da <command role="hg-cmd">hg log</command> sono utili se sapete già cosa state cercando, potreste aver bisogno di vedere una descrizione completa del cambiamento, o una lista dei file modificati, nel caso stiate tentando di capire se il changeset è quello che volevate. L&rsquo;opzione <option role="hg-opt-global">-v</option> (o <option role="hg-opt-global">--verbose</option>) del comando <command role="hg-cmd">hg log</command> vi fornisce questi dettagli aggiuntivi.</para>
 
       &interaction.tour.log-v;
 
-      <para id="x_2f">Se volete vedere sia la descrizione che il contenuto di un cambiamento, aggiungete l'opzione <option role="hg-opt-log">-p</option> (o <option role="hg-opt-log">--patch</option>). In questo modo il contenuto del cambiamento verrà stampato come un <emphasis>diff unificato</emphasis> (se non avete mai visto un diff unificato prima d'ora, date un'occhiata alla <xref linkend="sec:mq:patch"/> per un'introduzione).</para>
+      <para id="x_2f">Se volete vedere sia la descrizione che il contenuto di un cambiamento, aggiungete l&rsquo;opzione <option role="hg-opt-log">-p</option> (o <option role="hg-opt-log">--patch</option>). In questo modo il contenuto del cambiamento verrà stampato come un <emphasis>diff unificato</emphasis> (se non avete mai visto un diff unificato prima d&rsquo;ora, date un&rsquo;occhiata alla <xref linkend="sec:mq:patch"/> per un&rsquo;introduzione).</para>
 
       &interaction.tour.log-vp;
 
-      <para id="x_67e">L'opzione <option role="hg-opt-log">-p</option> è tremendamente utile, quindi merita di essere ricordata.</para>
+      <para id="x_67e">L&rsquo;opzione <option role="hg-opt-log">-p</option> è tremendamente utile, quindi merita di essere ricordata.</para>
 
     </sect2>
   </sect1>
 
     <para id="x_30">Facciamo una piccola pausa nella nostra esplorazione dei comandi di Mercurial per discutere lo schema secondo cui quei comandi lavorano, perché potreste trovarlo utile da tenere a mente nel seguito di questa panoramica.</para>
 
-    <para id="x_31">Mercurial adotta un approccio semplice e consistente per gestire le opzioni che potete passare ai comandi. Segue l'insieme di convenzioni per le opzioni comunemente usato nei moderni sistemi Linux e Unix.</para>
+    <para id="x_31">Mercurial adotta un approccio semplice e consistente per gestire le opzioni che potete passare ai comandi. Segue l&rsquo;insieme di convenzioni per le opzioni comunemente usato nei moderni sistemi Linux e Unix.</para>
 
     <itemizedlist>
       <listitem>
-	<para id="x_32">Ogni opzione ha un nome lungo. Per esempio, come avete già visto, il comando <command role="hg-cmd">hg log</command> accetta un'opzione <option role="hg-opt-log">--rev</option>.</para>
+	<para id="x_32">Ogni opzione ha un nome lungo. Per esempio, come avete già visto, il comando <command role="hg-cmd">hg log</command> accetta un&rsquo;opzione <option role="hg-opt-log">--rev</option>.</para>
       </listitem>
       <listitem>
 	<para id="x_33">La maggior parte delle opzioni ha anche un nome breve. Invece di <option role="hg-opt-log">--rev</option>, possiamo usare <option role="hg-opt-log">-r</option>. (Alcune opzioni non hanno un nome breve perché vengono usate raramente.)</para>
 
     <para id="x_36">Negli esempi contenuti in questo libro, di solito uso le opzioni brevi invece di quelle lunghe. Questo riflette semplicemente la mia preferenza, quindi non leggetevi nulla di particolarmente significativo.</para>
 
-    <para id="x_37">La maggior parte dei comandi che stampano un testo di qualche tipo stamperanno più testo quando gli verrà passata l'opzione <option role="hg-opt-global">-v</option> (o <option role="hg-opt-global">--verbose</option>) e meno testo quando gli verrà passata l'opzione <option role="hg-opt-global">-q</option> (o <option role="hg-opt-global">--quiet</option>).</para>
+    <para id="x_37">La maggior parte dei comandi che stampano un testo di qualche tipo stamperanno più testo quando gli verrà passata l&rsquo;opzione <option role="hg-opt-global">-v</option> (o <option role="hg-opt-global">--verbose</option>) e meno testo quando gli verrà passata l&rsquo;opzione <option role="hg-opt-global">-q</option> (o <option role="hg-opt-global">--quiet</option>).</para>
 
     <note>
       <title>La consistenza nella denominazione delle opzioni</title>
 
-      <para id="x_680">Quasi sempre, le opzioni dei comandi Mercurial usano nomi consistenti per fare riferimento agli stessi concetti. Per esempio, se un comando ha a che fare con i changeset, questi verranno sempre identificati tramite l'opzione <option role="hg-opt-log">--rev</option> o <option role="hg-opt-log">-r</option>. L'uso consistente dei nomi delle opzioni rende più facile ricordarsi quali opzioni sono accettate da un particolare comando.</para>
+      <para id="x_680">Quasi sempre, le opzioni dei comandi Mercurial usano nomi consistenti per fare riferimento agli stessi concetti. Per esempio, se un comando ha a che fare con i changeset, questi verranno sempre identificati tramite l&rsquo;opzione <option role="hg-opt-log">--rev</option> o <option role="hg-opt-log">-r</option>. L&rsquo;uso consistente dei nomi delle opzioni rende più facile ricordarsi quali opzioni sono accettate da un particolare comando.</para>
     </note>
 
   </sect1>
   <sect1>
     <title>Come effettuare e rivedere i cambiamenti</title>
 
-    <para id="x_38">Ora che sappiamo come ispezionare la cronologia in Mercurial, diamo un'occhiata al modo in cui si apportano e si esaminano i cambiamenti.</para>
+    <para id="x_38">Ora che sappiamo come ispezionare la cronologia in Mercurial, diamo un&rsquo;occhiata al modo in cui si apportano e si esaminano i cambiamenti.</para>
 
     <para id="x_39">Per cominciare, isoleremo il nostro esperimento in un apposito repository. Usiamo il comando <command role="hg-cmd">hg clone</command>, ma senza clonare il repository remoto, perché sarà sufficiente clonarne la copia locale che già possediamo. Una clonazione locale è molto più veloce rispetto a una clonazione attraverso la rete e, nella maggior parte dei casi, il clone di un repository locale utilizza anche una quantità inferiore di spazio su disco<footnote>
 	<para id="x_681">Il risparmio di spazio si ottiene quando i repository sorgente e destinazione sono sullo stesso file system, nel qual caso Mercurial userà collegamenti fisici per effettuare una condivisione copy-on-write dei suoi metadati interni. Se questa spiegazione non significa nulla per voi, non preoccupatevi: ogni cosa avviene in maniera trasparente e automatica, e non avete bisogno di capirla.</para>
 
     &interaction.tour.reclone;
 
-    <para id="x_3a">Come nota a margine, è buona pratica tenere da parte una copia <quote>intatta</quote> di un repository remoto, che potete usare per creare cloni temporanei o ambienti di prova per ogni attività che volete svolgere. Questo vi permette di lavorare su molteplici attività in parallelo, ognuna isolata dalle altre fino a quando non è completa e non siete pronti per reintegrarla. Dato che i cloni locali sono così economici, non c'è quasi alcuno spreco nel clonare e cancellare repository ogni volta che volete.</para>
+    <para id="x_3a">Come nota a margine, è buona pratica tenere da parte una copia <quote>intatta</quote> di un repository remoto, che potete usare per creare cloni temporanei o ambienti di prova per ogni attività che volete svolgere. Questo vi permette di lavorare su molteplici attività in parallelo, ognuna isolata dalle altre fino a quando non è completa e non siete pronti per reintegrarla. Dato che i cloni locali sono così economici, non c&rsquo;è quasi alcuno spreco nel clonare e cancellare repository ogni volta che volete.</para>
 
     <para id="x_3b">Nel nostro repository <filename class="directory">mio-hello</filename> abbiamo un file <filename>hello.c</filename> che contiene il classico programma <quote>ciao, mondo</quote>.</para>
 
     <tip>
       <title>Capire le patch</title>
 
-      <para id="x_683">Ricordate di dare un'occhiata alla <xref linkend="sec:mq:patch"/> se non sapete come interpretare il risultato del comando appena eseguito.</para>
+      <para id="x_683">Ricordate di dare un&rsquo;occhiata alla <xref linkend="sec:mq:patch"/> se non sapete come interpretare il risultato del comando appena eseguito.</para>
     </tip>
   </sect1>
   <sect1>
     <sect2>
       <title>Impostare un nome utente</title>
 
-      <para id="x_42">Quando provate a eseguire <command role="hg-cmd">hg commit</command> per la prima volta, non c'è alcuna garanzia che il comando abbia successo. Mercurial registra il vostro nome e indirizzo con ogni cambiamento che inserite, in modo che più tardi voi e gli altri siate in grado di dire chi lo ha effettuato. Mercurial prova a costruire automaticamente un nome utente ragionevole da usare per l'inserimento. Proverà ognuno dei seguenti metodi, in questo ordine.</para>
+      <para id="x_42">Quando provate a eseguire <command role="hg-cmd">hg commit</command> per la prima volta, non c&rsquo;è alcuna garanzia che il comando abbia successo. Mercurial registra il vostro nome e indirizzo con ogni cambiamento che inserite, in modo che più tardi voi e gli altri siate in grado di dire chi lo ha effettuato. Mercurial prova a costruire automaticamente un nome utente ragionevole da usare per l&rsquo;inserimento. Proverà ognuno dei seguenti metodi, in questo ordine.</para>
       <orderedlist>
-	<listitem><para id="x_43">La precedenza più alta verrà data al nome utente che segue l'opzione <option role="hg-opt-commit">-u</option> del comando <command role="hg-cmd">hg commit</command>.</para></listitem>
-	<listitem><para id="x_44">Successivamente, verrà controllato il valore della variabile d'ambiente <envar>HGUSER</envar>.</para></listitem>
-	<listitem><para id="x_45">Quindi, verrà usato l'elemento <envar role="rc-item-ui">username</envar> contenuto in un file chiamato <filename role="special">.hgrc</filename> che potreste aver creato nella vostra directory personale. Per vedere come dovrebbero apparire i contenuti di questo file, fate riferimento alla <xref linkend="sec:tour-basic:username"/> più avanti.</para></listitem>
-	<listitem><para id="x_46">Successivamente, verrà controllato il valore della variabile d'ambiente <envar>EMAIL</envar>.</para></listitem>
+	<listitem><para id="x_43">La precedenza più alta verrà data al nome utente che segue l&rsquo;opzione <option role="hg-opt-commit">-u</option> del comando <command role="hg-cmd">hg commit</command>.</para></listitem>
+	<listitem><para id="x_44">Successivamente, verrà controllato il valore della variabile d&rsquo;ambiente <envar>HGUSER</envar>.</para></listitem>
+	<listitem><para id="x_45">Quindi, verrà usato l&rsquo;elemento <envar role="rc-item-ui">username</envar> contenuto in un file chiamato <filename role="special">.hgrc</filename> che potreste aver creato nella vostra directory personale. Per vedere come dovrebbero apparire i contenuti di questo file, fate riferimento alla <xref linkend="sec:tour-basic:username"/> più avanti.</para></listitem>
+	<listitem><para id="x_46">Successivamente, verrà controllato il valore della variabile d&rsquo;ambiente <envar>EMAIL</envar>.</para></listitem>
 	<listitem><para id="x_47">Infine, Mercurial interrogherà il vostro sistema per trovare il vostro nome utente locale e il nome della vostra macchina, utilizzandoli poi per costruire un nome utente. Dato che questo processo risulta spesso in un nome utente che non è molto utile, Mercurial stamperà un messaggio di avvertimento nel caso sia costretto a ricorrere a questa alternativa.</para></listitem>
       </orderedlist>
       <para id="x_48">Se tutti questi meccanismi falliscono, Mercurial si fermerà stampando un messaggio di errore. In questo caso, non vi permetterà di eseguire il commit fino a quando non avrete impostato il vostro nome utente.</para>
-      <para id="x_49">Dovreste considerare la variabile d'ambiente <envar>HGUSER</envar> e l'opzione <option role="hg-opt-commit">-u</option> del comando <command role="hg-cmd">hg commit</command> come modi per rimpiazzare la selezione predefinita del nome utente da parte di Mercurial. Normalmente, il modo più semplice e robusto per impostare il vostro nome utente è quello di creare un file <filename role="special">.hgrc</filename>.</para>
+      <para id="x_49">Dovreste considerare la variabile d&rsquo;ambiente <envar>HGUSER</envar> e l&rsquo;opzione <option role="hg-opt-commit">-u</option> del comando <command role="hg-cmd">hg commit</command> come modi per rimpiazzare la selezione predefinita del nome utente da parte di Mercurial. Normalmente, il modo più semplice e robusto per impostare il vostro nome utente è quello di creare un file <filename role="special">.hgrc</filename>.</para>
       <sect3 id="sec:tour-basic:username">
 	<title>Creare un file di configurazione per Mercurial</title>
 
 	<tip>
 	  <title>La <quote>directory personale</quote> sotto Windows</title>
 
-	  <para id="x_716">In una installazione italiana di Windows, la vostra directory personale di solito corrisponde a una cartella chiamata con il vostro nome utente che si trova in <filename>C:\Documents and Settings</filename>. Potete scoprire l'esatto nome della vostra directory personale aprendo una finestra del prompt dei comandi e invocando il comando seguente.</para>
+	  <para id="x_716">In una installazione italiana di Windows, la vostra directory personale di solito corrisponde a una cartella chiamata con il vostro nome utente che si trova in <filename>C:\Documents and Settings</filename>. Potete scoprire l&rsquo;esatto nome della vostra directory personale aprendo una finestra del prompt dei comandi e invocando il comando seguente.</para>
 
 	  <screen><prompt>C:\></prompt> <userinput>echo %UserProfile%</userinput></screen>
 	</tip>
 [ui]
 username = Nome Cognome &lt;indirizzo.email@example.org&gt;</programlisting>
 
-	<para id="x_4b">La riga <quote><literal>[ui]</literal></quote> comincia una <emphasis>sezione</emphasis> del file di configurazione, così potete leggere la riga <quote><literal>username = ...</literal></quote> con il significato di <quote>imposta il valore dell'elemento <literal>username</literal> nella sezione <literal>ui</literal></quote>. Una sezione continua fino a quando ne comincia una nuova o fino alla fine del file. Mercurial ignora le righe vuote e tratta il testo di ogni riga che comincia con il carattere <quote><literal>#</literal></quote> come un commento.</para>
+	<para id="x_4b">La riga <quote><literal>[ui]</literal></quote> comincia una <emphasis>sezione</emphasis> del file di configurazione, così potete leggere la riga <quote><literal>username = ...</literal></quote> con il significato di <quote>imposta il valore dell&rsquo;elemento <literal>username</literal> nella sezione <literal>ui</literal></quote>. Una sezione continua fino a quando ne comincia una nuova o fino alla fine del file. Mercurial ignora le righe vuote e tratta il testo di ogni riga che comincia con il carattere <quote><literal>#</literal></quote> come un commento.</para>
       </sect3>
 
       <sect3>
 	<title>Scegliere un nome utente</title>
 
-	<para id="x_4c">Potete usare il testo che preferite come valore dell'elemento di configurazione <literal>username</literal>, dato che questa informazione serve per essere letta da altre persone e non verrà interpretata da Mercurial. La convenzione seguita dalla maggior parte delle persone è quella di usare il proprio nome e indirizzo email, come nell'esempio precedente.</para>
+	<para id="x_4c">Potete usare il testo che preferite come valore dell&rsquo;elemento di configurazione <literal>username</literal>, dato che questa informazione serve per essere letta da altre persone e non verrà interpretata da Mercurial. La convenzione seguita dalla maggior parte delle persone è quella di usare il proprio nome e indirizzo email, come nell&rsquo;esempio precedente.</para>
 	<note>
 	  <para id="x_4d">Il server web predefinito di Mercurial offusca gli indirizzi email, per rendere la vita difficile agli strumenti che gli spammer usano per raccogliere nuovi indirizzi. Questo riduce la possibilità che cominciate a ricevere una maggior quantità di spazzatura nella vostra casella email se pubblicate un repository Mercurial sul web.</para></note>
       </sect3>
     <sect2>
       <title>Scrivere un messaggio di commit</title>
 
-      <para id="x_4e">Quando inseriamo un cambiamento, Mercurial apre un editor di testo per farci scrivere un <emphasis>messaggio di commit</emphasis> allo scopo di descrivere le modifiche che abbiamo effettuato in questo changeset. Il messaggio verrà registrato per i lettori interessati a sapere quello che abbiamo fatto e perché, e verrà stampato dalle invocazioni di <command role="hg-cmd">hg log</command> successive alla terminazione dell'inserimento.</para>
+      <para id="x_4e">Quando inseriamo un cambiamento, Mercurial apre un editor di testo per farci scrivere un <emphasis>messaggio di commit</emphasis> allo scopo di descrivere le modifiche che abbiamo effettuato in questo changeset. Il messaggio verrà registrato per i lettori interessati a sapere quello che abbiamo fatto e perché, e verrà stampato dalle invocazioni di <command role="hg-cmd">hg log</command> successive alla terminazione dell&rsquo;inserimento.</para>
 
        &interaction.tour.commit;
 
-      <para id="x_4f">L'editor aperto dal comando <command role="hg-cmd">hg commit</command> conterrà una o due righe vuote, seguite da un certo numero di righe che cominciano con <quote><literal>HG:</literal></quote>.</para>
+      <para id="x_4f">L&rsquo;editor aperto dal comando <command role="hg-cmd">hg commit</command> conterrà una o due righe vuote, seguite da un certo numero di righe che cominciano con <quote><literal>HG:</literal></quote>.</para>
 
     <programlisting>
 Potete digitare qui il vostro messaggio di commit.
     <sect2>
       <title>Abortire un commit</title>
 
-      <para id="x_54">Se decidete di non voler eseguire l'inserimento mentre state scrivendo il messaggio di commit, vi basta uscire dal vostro editor senza salvare il file che contiene il messaggio. Questo eviterà che il repository e la directory di lavoro vengano alterati in alcun modo.</para>
+      <para id="x_54">Se decidete di non voler eseguire l&rsquo;inserimento mentre state scrivendo il messaggio di commit, vi basta uscire dal vostro editor senza salvare il file che contiene il messaggio. Questo eviterà che il repository e la directory di lavoro vengano alterati in alcun modo.</para>
     </sect2>
 
     <sect2>
       <title>Ammirare la nostra nuova opera</title>
 
-      <para id="x_56">Una volta che abbiamo terminato l'inserimento, possiamo usare il comando <command role="hg-cmd">hg tip</command> per visualizzare il changeset che abbiamo appena creato. Questo comando produce una stampa identica a quella del comando <command role="hg-cmd">hg log</command>, ma mostra solamente la revisione più recente nel repository.</para>
+      <para id="x_56">Una volta che abbiamo terminato l&rsquo;inserimento, possiamo usare il comando <command role="hg-cmd">hg tip</command> per visualizzare il changeset che abbiamo appena creato. Questo comando produce una stampa identica a quella del comando <command role="hg-cmd">hg log</command>, ma mostra solamente la revisione più recente nel repository.</para>
 
       &interaction.tour.tip;
 
       <para id="x_57">Ci riferiremo alla revisione più recente nel repository come alla <emphasis>revisione di punta</emphasis>, o semplicemente la <emphasis>punta</emphasis>.</para>
 
-      <para id="x_684">Notate che il comando <command role="hg-cmd">hg tip</command> accetta molte delle stesse opzioni viste per <command role="hg-cmd">hg log</command>, quindi l'opzione <option role="hg-opt-global">-v</option> nell'esempio precedente chiede al comando di <quote>essere verboso</quote> e l'opzione <option role="hg-opt-tip">-p</option> specifica di <quote>stampare una patch</quote>. L'uso di <option role="hg-opt-tip">-p</option> per stampare le patch è un altro esempio della denominazione consistente che avevamo menzionato in precedenza.</para>
+      <para id="x_684">Notate che il comando <command role="hg-cmd">hg tip</command> accetta molte delle stesse opzioni viste per <command role="hg-cmd">hg log</command>, quindi l&rsquo;opzione <option role="hg-opt-global">-v</option> nell&rsquo;esempio precedente chiede al comando di <quote>essere verboso</quote> e l&rsquo;opzione <option role="hg-opt-tip">-p</option> specifica di <quote>stampare una patch</quote>. L&rsquo;uso di <option role="hg-opt-tip">-p</option> per stampare le patch è un altro esempio della denominazione consistente che avevamo menzionato in precedenza.</para>
     </sect2>
   </sect1>
 
 
       &interaction.tour.clone-pull;
 
-      <para id="x_5a">Useremo il comando <command role="hg-cmd">hg pull</command> per propagare i cambiamenti dal repository <filename class="directory">mio-hello</filename> al repository <filename class="directory">hello-estrazione</filename>. Tuttavia, estrarre alla cieca cambiamenti sconosciuti da un repository è una prospettiva che può incutere qualche timore. Mercurial fornisce il comando <command role="hg-cmd">hg incoming</command> proprio allo scopo di elencare quali cambiamenti <emphasis>verrebbero</emphasis> estratti dal repository senza effettivamente procedere con l'operazione.</para>
+      <para id="x_5a">Useremo il comando <command role="hg-cmd">hg pull</command> per propagare i cambiamenti dal repository <filename class="directory">mio-hello</filename> al repository <filename class="directory">hello-estrazione</filename>. Tuttavia, estrarre alla cieca cambiamenti sconosciuti da un repository è una prospettiva che può incutere qualche timore. Mercurial fornisce il comando <command role="hg-cmd">hg incoming</command> proprio allo scopo di elencare quali cambiamenti <emphasis>verrebbero</emphasis> estratti dal repository senza effettivamente procedere con l&rsquo;operazione.</para>
 
       &interaction.tour.incoming;
 
-      <para id="x_5c">Propagare i cambiamenti in un repository è semplicemente questione di eseguire il comando <command role="hg-cmd">hg pull</command>, dicendogli opzionalmente da quale repository compiere l'estrazione.</para>
+      <para id="x_5c">Propagare i cambiamenti in un repository è semplicemente questione di eseguire il comando <command role="hg-cmd">hg pull</command>, dicendogli opzionalmente da quale repository compiere l&rsquo;estrazione.</para>
 
       &interaction.tour.pull;
 
-      <para id="x_5d">Come potete vedere se confrontate il risultato di <command role="hg-cmd">hg tip</command> prima e dopo, abbiamo propagato con successo i cambiamenti nel nostro repository. Tuttavia, Mercurial separa l'operazione di estrazione dei cambiamenti da quella di aggiornamento della directory di lavoro. Rimane ancora un passo da fare prima di poter vedere i cambiamenti appena estratti comparire nella directory di lavoro.</para>
+      <para id="x_5d">Come potete vedere se confrontate il risultato di <command role="hg-cmd">hg tip</command> prima e dopo, abbiamo propagato con successo i cambiamenti nel nostro repository. Tuttavia, Mercurial separa l&rsquo;operazione di estrazione dei cambiamenti da quella di aggiornamento della directory di lavoro. Rimane ancora un passo da fare prima di poter vedere i cambiamenti appena estratti comparire nella directory di lavoro.</para>
 
       <tip>
 	<title>Estrarre cambiamenti specifici</title>
 
-	<para id="x_5b">&Egrave; possibile che, a causa del ritardo tra l'esecuzione di <command role="hg-cmd">hg incoming</command> e <command role="hg-cmd">hg pull</command>, non riusciate vedere tutti i changeset che verranno prelevati dall'altro repository. Supponete di voler estrarre cambiamenti da un repository che si trovi in rete da qualche parte. Mentre state osservando il risultato di <command role="hg-cmd">hg incoming</command>, ma prima che riusciate a estrarre quei cambiamenti, qualcuno potrebbe aver inserito qualcosa nel repository remoto. Questo significa che è possibile estrarre più cambiamenti di quelil esaminati tramite <command role="hg-cmd">hg incoming</command>.</para>
+	<para id="x_5b">&Egrave; possibile che, a causa del ritardo tra l&rsquo;esecuzione di <command role="hg-cmd">hg incoming</command> e <command role="hg-cmd">hg pull</command>, non riusciate vedere tutti i changeset che verranno prelevati dall&rsquo;altro repository. Supponete di voler estrarre cambiamenti da un repository che si trovi in rete da qualche parte. Mentre state osservando il risultato di <command role="hg-cmd">hg incoming</command>, ma prima che riusciate a estrarre quei cambiamenti, qualcuno potrebbe aver inserito qualcosa nel repository remoto. Questo significa che è possibile estrarre più cambiamenti di quelil esaminati tramite <command role="hg-cmd">hg incoming</command>.</para>
 
-	<para id="x_718">Se volete estrarre solamente quei particolari cambiamenti che sono stati elencati da <command role="hg-cmd">hg incoming</command>, o avete qualche altra ragione per estrarre un sottoinsieme dei cambiamenti, è sufficiente utilizzare l'identificatore di changeset del cambiamento che volete estrarre, e.g. <command>hg pull -r7e95bb</command>.</para>
+	<para id="x_718">Se volete estrarre solamente quei particolari cambiamenti che sono stati elencati da <command role="hg-cmd">hg incoming</command>, o avete qualche altra ragione per estrarre un sottoinsieme dei cambiamenti, è sufficiente utilizzare l&rsquo;identificatore di changeset del cambiamento che volete estrarre, e.g. <command>hg pull -r7e95bb</command>.</para>
       </tip>
     </sect2>
 
     <sect2>
       <title>Aggiornare la directory di lavoro</title>
 
-      <para id="x_5e">Finora abbiamo glissato sulla relazione tra il repository e la sua directory di lavoro. Il comando <command role="hg-cmd">hg pull</command> che abbiamo eseguito nella <xref linkend="sec:tour:pull"/> ha propagato i cambiamenti nel repository ma, se controlliamo, non c'è alcuna traccia di quei cambiamenti nella directory di lavoro. Questo accade perché il comportamento predefinito di <command role="hg-cmd">hg pull</command> prevede di non modificare la directory di lavoro. Per fare questo, dobbiamo invece usare il comando <command role="hg-cmd">hg update</command>.</para>
+      <para id="x_5e">Finora abbiamo glissato sulla relazione tra il repository e la sua directory di lavoro. Il comando <command role="hg-cmd">hg pull</command> che abbiamo eseguito nella <xref linkend="sec:tour:pull"/> ha propagato i cambiamenti nel repository ma, se controlliamo, non c&rsquo;è alcuna traccia di quei cambiamenti nella directory di lavoro. Questo accade perché il comportamento predefinito di <command role="hg-cmd">hg pull</command> prevede di non modificare la directory di lavoro. Per fare questo, dobbiamo invece usare il comando <command role="hg-cmd">hg update</command>.</para>
 
       &interaction.tour.update;
 
-      <para id="x_5f">Potrebbe sembrare un po' strano che <command role="hg-cmd">hg pull</command> non aggiorni automaticamente la directory di lavoro, ma c'è una buona ragione per questo: <command role="hg-cmd">hg update</command> è in grado di aggiornare la directory di lavoro allo stato in cui era in <emphasis>qualsiasi revisione</emphasis> contenuta nella cronologia del repository. Se la vostra directory di lavoro fosse stata aggiornata a una vecchia revisione&emdash;per cercare l'origine di un bug, diciamo&emdash;potreste non essere terribilmente contenti di vedere il comando <command role="hg-cmd">hg pull</command> da voi eseguito aggiornare automaticamente la directory di lavoro a una nuova revisione.</para>
+      <para id="x_5f">Potrebbe sembrare un po&rsquo; strano che <command role="hg-cmd">hg pull</command> non aggiorni automaticamente la directory di lavoro, ma c&rsquo;è una buona ragione per questo: <command role="hg-cmd">hg update</command> è in grado di aggiornare la directory di lavoro allo stato in cui era in <emphasis>qualsiasi revisione</emphasis> contenuta nella cronologia del repository. Se la vostra directory di lavoro fosse stata aggiornata a una vecchia revisione&emdash;per cercare l&rsquo;origine di un bug, diciamo&emdash;potreste non essere terribilmente contenti di vedere il comando <command role="hg-cmd">hg pull</command> da voi eseguito aggiornare automaticamente la directory di lavoro a una nuova revisione.</para>
 
-      <para id="x_60">Dato che la sequenza di estrazione e aggiornamento è così comune, Mercurial vi permette di combinare le due operazioni passando l'opzione <option role="hg-opt-pull">-u</option> al comando <command role="hg-cmd">hg pull</command>.</para>
+      <para id="x_60">Dato che la sequenza di estrazione e aggiornamento è così comune, Mercurial vi permette di combinare le due operazioni passando l&rsquo;opzione <option role="hg-opt-pull">-u</option> al comando <command role="hg-cmd">hg pull</command>.</para>
 
-      <para id="x_61">Se tornate indietro alla <xref linkend="sec:tour:pull"/> e osservate il testo visualizzato dal comando <command role="hg-cmd">hg pull</command> eseguito senza l'opzione <option role="hg-opt-pull">-u</option>, potete vedere che contiene un promemoria utile a ricordarci che dobbiamo effettuare un passo esplicito per aggiornare la directory di lavoro.</para>
+      <para id="x_61">Se tornate indietro alla <xref linkend="sec:tour:pull"/> e osservate il testo visualizzato dal comando <command role="hg-cmd">hg pull</command> eseguito senza l&rsquo;opzione <option role="hg-opt-pull">-u</option>, potete vedere che contiene un promemoria utile a ricordarci che dobbiamo effettuare un passo esplicito per aggiornare la directory di lavoro.</para>
 
       <para id="x_62">Per scoprire a quale revisione è aggiornata la directory di lavoro, usate il comando <command role="hg-cmd">hg parents</command>.</para>
 
 
       &interaction.tour.older;
 
-      <para id="x_65">Se omettete una revisione esplicita, <command role="hg-cmd">hg update</command> effettuerà l'aggiornamento alla revisione più recente (la revisione di punta), come mostrato nella seconda invocazione di <command role="hg-cmd">hg update</command> nell'esempio precedente.</para>
+      <para id="x_65">Se omettete una revisione esplicita, <command role="hg-cmd">hg update</command> effettuerà l&rsquo;aggiornamento alla revisione più recente (la revisione di punta), come mostrato nella seconda invocazione di <command role="hg-cmd">hg update</command> nell&rsquo;esempio precedente.</para>
     </sect2>
 
     <sect2>
       <title>Pubblicare i cambiamenti in un altro repository</title>
 
-      <para id="x_66">Mercurial ci permette di trasmettere i nostri cambiamenti dal repository in cui ci troviamo verso un altro repository. Come per l'esempio del comando <command role="hg-cmd">hg pull</command> appena illustrato, creeremo un repository temporaneo a cui trasmettere i nostri cambiamenti.</para>
+      <para id="x_66">Mercurial ci permette di trasmettere i nostri cambiamenti dal repository in cui ci troviamo verso un altro repository. Come per l&rsquo;esempio del comando <command role="hg-cmd">hg pull</command> appena illustrato, creeremo un repository temporaneo a cui trasmettere i nostri cambiamenti.</para>
 
       &interaction.tour.clone-push;
 
 
       &interaction.tour.outgoing;
 
-      <para id="x_68">E il comando <command role="hg-cmd">hg push</command> esegue l'effettiva trasmissione.</para>
+      <para id="x_68">E il comando <command role="hg-cmd">hg push</command> esegue l&rsquo;effettiva trasmissione.</para>
 
       &interaction.tour.push;
 
-      <para id="x_69">Allo stesso modo di <command role="hg-cmd">hg pull</command>, il comando <command role="hg-cmd">hg push</command> non aggiorna la directory di lavoro nel repository verso il quale sta trasmettendo i cambiamenti. Diversamente da <command role="hg-cmd">hg pull</command>, <command role="hg-cmd">hg push</command> non fornisce un'opzione <literal>-u</literal> che aggiorni la directory di lavoro dell'altro repository. Questa asimmetria è voluta: il repository verso il quale stiamo trasmettendo potrebbe essere su un server remoto e condiviso da molte persone. Se dovessimo aggiornare la sua directory di lavoro mentre altre persone ci stanno lavorando, il loro lavoro sarebbe rovinato.</para>
+      <para id="x_69">Allo stesso modo di <command role="hg-cmd">hg pull</command>, il comando <command role="hg-cmd">hg push</command> non aggiorna la directory di lavoro nel repository verso il quale sta trasmettendo i cambiamenti. Diversamente da <command role="hg-cmd">hg pull</command>, <command role="hg-cmd">hg push</command> non fornisce un&rsquo;opzione <literal>-u</literal> che aggiorni la directory di lavoro dell&rsquo;altro repository. Questa asimmetria è voluta: il repository verso il quale stiamo trasmettendo potrebbe essere su un server remoto e condiviso da molte persone. Se dovessimo aggiornare la sua directory di lavoro mentre altre persone ci stanno lavorando, il loro lavoro sarebbe rovinato.</para>
 
       <para id="x_6a">Cosa succede se proviamo a estrarre o trasmettere cambiamenti che il repository contiene già? Nulla di particolarmente eccitante.</para>
 
     <sect2>
       <title>Ubicazioni predefinite</title>
 
-      <para id="x_719">Quando cloniamo un repository, Mercurial registra l'ubicazione del repository che abbiamo clonato nel file <filename>.hg/hgrc</filename> del nuovo repository. I comandi <command>hg pull</command> e <command>hg push</command> useranno quella ubicazione come impostazione predefinita quando vengono invocati senza fornire esplicitamente un percorso. Anche i comandi <command>hg incoming</command> e <command>hg outgoing</command> si comporteranno allo stesso modo.</para>
+      <para id="x_719">Quando cloniamo un repository, Mercurial registra l&rsquo;ubicazione del repository che abbiamo clonato nel file <filename>.hg/hgrc</filename> del nuovo repository. I comandi <command>hg pull</command> e <command>hg push</command> useranno quella ubicazione come impostazione predefinita quando vengono invocati senza fornire esplicitamente un percorso. Anche i comandi <command>hg incoming</command> e <command>hg outgoing</command> si comporteranno allo stesso modo.</para>
 
       <para id="x_71a">Se aprite il file <filename>.hg/hgrc</filename> di un repository con un editor di testo, vedrete contenuti simili ai seguenti.</para>
 

it/ch03-tour-merge.xml

   <?dbhtml filename="una-panoramica-di-mercurial-le-unioni.html"?>
   <title>Una panoramica di Mercurial: le unioni</title>
 
-  <para id="x_338">Finora abbiamo parlato di come clonare un repository, effettuare modifiche in un repository ed estrarre o trasmettere cambiamenti da un repository all'altro. Il nostro prossimo passo sarà quello di <emphasis>unire</emphasis> le modifiche provenienti da repository separati.</para>
+  <para id="x_338">Finora abbiamo parlato di come clonare un repository, effettuare modifiche in un repository ed estrarre o trasmettere cambiamenti da un repository all&rsquo;altro. Il nostro prossimo passo sarà quello di <emphasis>unire</emphasis> le modifiche provenienti da repository separati.</para>
 
   <sect1>
     <title>Unire flussi di lavoro</title>
 	<para id="x_33a">Alice e Bruno hanno entrambi una copia personale di un repository per un progetto su cui stanno collaborando. Mentre Alice corregge un bug nel suo repository, Bruno aggiunge una nuova funzione nel proprio. Entrambi vogliono che il repository condiviso contenga sia la correzione del bug sia la nuova funzione.</para>
       </listitem>
       <listitem>
-	<para id="x_33b">Cinzia lavora frequentemente su più attività differenti alla volta per un singolo progetto, ognuna isolata al sicuro nel proprio repository. Lavorando in questo modo, Cinzia ha spesso bisogno di unire una parte del proprio lavoro con un'altra.</para>
+	<para id="x_33b">Cinzia lavora frequentemente su più attività differenti alla volta per un singolo progetto, ognuna isolata al sicuro nel proprio repository. Lavorando in questo modo, Cinzia ha spesso bisogno di unire una parte del proprio lavoro con un&rsquo;altra.</para>
       </listitem>
     </itemizedlist>
 
 
     &interaction.tour.merge.clone;
 
-    <para id="x_33d">Ora abbiamo due copie di <filename>hello.c</filename> con contenuti differenti e le cronologie dei due repository divergono l'una dall'altra, come illustrato nella <xref linkend="fig:tour-merge:sep-repos"/>. Ecco la copia del nostro file presente nel primo repository.</para>
+    <para id="x_33d">Ora abbiamo due copie di <filename>hello.c</filename> con contenuti differenti e le cronologie dei due repository divergono l&rsquo;una dall&rsquo;altra, come illustrato nella <xref linkend="fig:tour-merge:sep-repos"/>. Ecco la copia del nostro file presente nel primo repository.</para>
 
     &interaction.tour.merge.cat1;
 
-    <para id="x_722">Ed ecco la versione leggermente differente contenuta nell'altro repository.</para>
+    <para id="x_722">Ed ecco la versione leggermente differente contenuta nell&rsquo;altro repository.</para>
 
     &interaction.tour.merge.cat2;
 
       </mediaobject>
     </figure>
 
-    <para id="x_33f">Sappiamo già che l'estrazione dei cambiamenti dal nostro repository <filename class="directory">mio-hello</filename> non avrà alcun effetto sulla directory di lavoro.</para>
+    <para id="x_33f">Sappiamo già che l&rsquo;estrazione dei cambiamenti dal nostro repository <filename class="directory">mio-hello</filename> non avrà alcun effetto sulla directory di lavoro.</para>
 
     &interaction.tour.merge.pull;
 
     <sect2>
       <title>Le teste di un repository</title>
 
-      <para id="x_341">Come ricorderete, Mercurial memorizza l'identità del genitore di ogni changeset. Se un cambiamento possiede un genitore, lo chiamiamo figlio o discendente del genitore. Una testa è un changeset che non ha figli. Quindi, la revisione di punta è una testa, perché la revisione più recente in un repository non possiede alcun figlio. Ci sono occasioni in cui un repository può contenere più di una testa.</para>
+      <para id="x_341">Come ricorderete, Mercurial memorizza l&rsquo;identità del genitore di ogni changeset. Se un cambiamento possiede un genitore, lo chiamiamo figlio o discendente del genitore. Una testa è un changeset che non ha figli. Quindi, la revisione di punta è una testa, perché la revisione più recente in un repository non possiede alcun figlio. Ci sono occasioni in cui un repository può contenere più di una testa.</para>
 
       <figure id="fig:tour-merge:pull">
 	<title>I contenuti del repository dopo aver propagato i cambiamenti da <filename class="directory">mio-hello</filename> a <filename class="directory">mio-nuovo-hello</filename></title>
 	</mediaobject>
       </figure>
 
-      <para id="x_343">Dalla <xref linkend="fig:tour-merge:pull"/>, potete vedere l'effetto della propagazione dei cambiamenti dal repository  <filename class="directory">mio-hello</filename> al repository <filename class="directory">mio-nuovo-hello</filename>. La cronologia già presente in <filename class="directory">mio-nuovo-hello</filename> non viene toccata, ma al repository è stata aggiunta una nuova revisione. Riferendoci alla <xref linkend="fig:tour-merge:sep-repos"/>, possiamo vedere che nel nuovo repository l'<emphasis>identificatore di changeset</emphasis> rimane lo stesso, ma il <emphasis>numero di revisione</emphasis> è cambiato. (Questo, incidentalmente, è un buon esempio del perché sia inopportuno usare i numeri di revisione per discutere i changeset.) Possiamo vedere le teste di un repository utilizzando il comando <command role="hg-cmd">hg heads</command>.</para>
+      <para id="x_343">Dalla <xref linkend="fig:tour-merge:pull"/>, potete vedere l&rsquo;effetto della propagazione dei cambiamenti dal repository  <filename class="directory">mio-hello</filename> al repository <filename class="directory">mio-nuovo-hello</filename>. La cronologia già presente in <filename class="directory">mio-nuovo-hello</filename> non viene toccata, ma al repository è stata aggiunta una nuova revisione. Riferendoci alla <xref linkend="fig:tour-merge:sep-repos"/>, possiamo vedere che nel nuovo repository l&rsquo;<emphasis>identificatore di changeset</emphasis> rimane lo stesso, ma il <emphasis>numero di revisione</emphasis> è cambiato. (Questo, incidentalmente, è un buon esempio del perché sia inopportuno usare i numeri di revisione per discutere i changeset.) Possiamo vedere le teste di un repository utilizzando il comando <command role="hg-cmd">hg heads</command>.</para>
 
       &interaction.tour.merge.heads;
     </sect2>
 
     <sect2>
-      <title>Effettuare l'unione</title>
+      <title>Effettuare l&rsquo;unione</title>
 
       <para id="x_344">Cosa succede se proviamo a usare normalmente il comando <command role="hg-cmd">hg update</command> per aggiornare la directory di lavoro alla nuova punta?</para>
 
       &interaction.tour.merge.update;
 
-      <para id="x_345">Mercurial ci sta dicendo che <command role="hg-cmd">hg update</command> non è in grado di effettuare un'unione. Il comando non aggiornerà la directory di lavoro se pensa che potremmo voler eseguire un'unione, a meno che non gli chiediamo esplicitamente di farlo. (Incidentalmente, forzare l'aggiornamento tramite <command>hg update -C</command> provocherebbe la perdita di tutte le modifiche contenute nella directory di lavoro e non ancora inserite nel repository.)</para>
+      <para id="x_345">Mercurial ci sta dicendo che <command role="hg-cmd">hg update</command> non è in grado di effettuare un&rsquo;unione. Il comando non aggiornerà la directory di lavoro se pensa che potremmo voler eseguire un&rsquo;unione, a meno che non gli chiediamo esplicitamente di farlo. (Incidentalmente, forzare l&rsquo;aggiornamento tramite <command>hg update -C</command> provocherebbe la perdita di tutte le modifiche contenute nella directory di lavoro e non ancora inserite nel repository.)</para>
 
-      <para id="x_723">Per avviare un'unione tra le due teste, usiamo il comando <command role="hg-cmd">hg merge</command>.</para>
+      <para id="x_723">Per avviare un&rsquo;unione tra le due teste, usiamo il comando <command role="hg-cmd">hg merge</command>.</para>
 
       &interaction.tour.merge.merge;
 
-      <para id="x_347">Il contenuto del file <filename>hello.c</filename> viene sistemato. L'operazione aggiorna la directory di lavoro in modo che contenga le modifiche provenienti da <emphasis>entrambe</emphasis> le teste, cosa che si riflette sia nell'elenco visualizzato dal comando <command role="hg-cmd">hg parents</command> sia nei contenuti del file <filename>hello.c</filename>.</para>
+      <para id="x_347">Il contenuto del file <filename>hello.c</filename> viene sistemato. L&rsquo;operazione aggiorna la directory di lavoro in modo che contenga le modifiche provenienti da <emphasis>entrambe</emphasis> le teste, cosa che si riflette sia nell&rsquo;elenco visualizzato dal comando <command role="hg-cmd">hg parents</command> sia nei contenuti del file <filename>hello.c</filename>.</para>
 
       &interaction.tour.merge.parents;
     </sect2>
 
     <sect2>
-      <title>Inserire i risultati dell'unione nel repository</title>
+      <title>Inserire i risultati dell&rsquo;unione nel repository</title>
 
-      <para id="x_348">Ogni volta che eseguiamo un'unione, il comando <command role="hg-cmd">hg parents</command> mostrerà due genitori fino a quando non invocheremo <command role="hg-cmd">hg commit</command> per inserire i risultati dell'unione nel repository.</para>
+      <para id="x_348">Ogni volta che eseguiamo un&rsquo;unione, il comando <command role="hg-cmd">hg parents</command> mostrerà due genitori fino a quando non invocheremo <command role="hg-cmd">hg commit</command> per inserire i risultati dell&rsquo;unione nel repository.</para>
 
       &interaction.tour.merge.commit;
 
 
       &interaction.tour.merge.tip;
 
-      <para id="x_34a">Nella <xref linkend="fig:tour-merge:merge"/>, potete vedere una rappresentazione di quanto accade alla directory di lavoro durante l'unione e di come questo abbia effetto sul repository quando avviene l'inserimento. Durante l'unione, la directory di lavoro possiede due changeset genitori che poi diventano i genitori del nuovo changeset.</para>
+      <para id="x_34a">Nella <xref linkend="fig:tour-merge:merge"/>, potete vedere una rappresentazione di quanto accade alla directory di lavoro durante l&rsquo;unione e di come questo abbia effetto sul repository quando avviene l&rsquo;inserimento. Durante l&rsquo;unione, la directory di lavoro possiede due changeset genitori che poi diventano i genitori del nuovo changeset.</para>
 
       <figure id="fig:tour-merge:merge">
-	<title>Lo stato della directory di lavoro e del repository durante l'unione e dopo l'inserimento</title>
+	<title>Lo stato della directory di lavoro e del repository durante l&rsquo;unione e dopo l&rsquo;inserimento</title>
 	<mediaobject>
 	  <imageobject>
 	    <imagedata fileref="figs/tour-merge-merge.png"/>
 	</mediaobject>
       </figure>
 
-      <para id="x_69c">Talvolta si dice che un'unione è composta da due <emphasis>parti</emphasis>: la parte sinistra è costituita dal primo genitore elencato da <command role="hg-cmd">hg parents</command> e la parte destra dal secondo. Se per esempio la directory di lavoro si fosse trovata alla revisione 5 prima che cominciassimo l'unione, quella revisione sarebbe diventata la parte sinistra dell'unione.</para>
+      <para id="x_69c">Talvolta si dice che un&rsquo;unione è composta da due <emphasis>parti</emphasis>: la parte sinistra è costituita dal primo genitore elencato da <command role="hg-cmd">hg parents</command> e la parte destra dal secondo. Se per esempio la directory di lavoro si fosse trovata alla revisione 5 prima che cominciassimo l&rsquo;unione, quella revisione sarebbe diventata la parte sinistra dell&rsquo;unione.</para>
     </sect2>
   </sect1>
 
 
     <para id="x_34e">Mercurial non è dotato di alcuna funzione predefinita per gestire i conflitti. Invece, richiama un programma esterno, di solito uno che mostra un qualche tipo di interfaccia grafica per la risoluzione dei conflitti, trovato tra i tanti strumenti di unione differenti che è probabile siano installati sul vostro sistema. Come prima cosa, Mercurial prova a cercare alcuni strumenti di unione completamente automatici; poi, se non riesce a trovarli (perché il processo di risoluzione richiede una guida umana) o se non sono presenti, prova a richiamare diversi strumenti grafici di unione.</para>
 
-    <para id="x_34f">&Egrave; anche possibile far eseguire a Mercurial uno specifico programma, impostando il valore della variable d'ambiente <envar>HGMERGE</envar> al nome del vostro programma preferito.</para>
+    <para id="x_34f">&Egrave; anche possibile far eseguire a Mercurial uno specifico programma, impostando il valore della variable d&rsquo;ambiente <envar>HGMERGE</envar> al nome del vostro programma preferito.</para>
 
     <sect2>
       <title>Usare uno strumento grafico di unione</title>
 	</listitem>
 	<listitem><para id="x_353">a destra troviamo la <quote>loro</quote> versione del file, quella che proviene dal changeset che stiamo cercando di incorporare.</para>
 	</listitem></itemizedlist>
-      <para id="x_354">Il pannello sottostante contiene il <emphasis>risultato</emphasis> corrente dell'unione. Il nostro compito è quello di sostituire tutto il testo in rosso, che indica conflitti irrisolti, con una qualche combinazione ragionevole della <quote>nostra</quote> e della <quote>loro</quote> versione del file.</para>
+      <para id="x_354">Il pannello sottostante contiene il <emphasis>risultato</emphasis> corrente dell&rsquo;unione. Il nostro compito è quello di sostituire tutto il testo in rosso, che indica conflitti irrisolti, con una qualche combinazione ragionevole della <quote>nostra</quote> e della <quote>loro</quote> versione del file.</para>
 
       <para id="x_355">Tutti e quattro questi pannelli sono <emphasis>collegati tra loro</emphasis>: se ci spostiamo in verticale o in orizzontale in un pannello qualsiasi, gli altri vengono aggiornati per mostrare le sezioni corrispondenti dei rispettivi file.</para>
 
 
       <para id="x_357">Per ogni porzione conflittuale del file, possiamo scegliere di risolvere il conflitto usando una qualche combinazione di testo dalla versione base, dalla nostra, o dalla loro. Possiamo anche modificare manualmente il file risultante in ogni momento, nel caso avessimo bisogno di effettuare ulteriori cambiamenti.</para>
 
-      <para id="x_358">Esistono <emphasis>molti</emphasis> strumenti per gestire l'unione di file, davvero troppi per elencarli qui. Si differenziano a seconda della piattaforma per cui sono disponibili e delle loro particolari forze e debolezze. La maggior parte è calibrata per unire file contenenti testo semplice, mentre alcuni sono orientati a particolari formati di file (generalmente XML).</para>
+      <para id="x_358">Esistono <emphasis>molti</emphasis> strumenti per gestire l&rsquo;unione di file, davvero troppi per elencarli qui. Si differenziano a seconda della piattaforma per cui sono disponibili e delle loro particolari forze e debolezze. La maggior parte è calibrata per unire file contenenti testo semplice, mentre alcuni sono orientati a particolari formati di file (generalmente XML).</para>
     </sect2>
 
     <sect2>
 
       &interaction.tour-merge-conflict.cousin;
 
-      <para id="x_35b">E ora aggiungiamo un altro clone, per simulare qualcun altro che effettui un cambiamento al file. (Questo suggerisce l'idea che non è affatto inusuale ritrovarsi a unire tra loro i propri repository contenenti attività isolate, risolvendo i conflitti incontrati nel corso di questo processo.)</para>
+      <para id="x_35b">E ora aggiungiamo un altro clone, per simulare qualcun altro che effettui un cambiamento al file. (Questo suggerisce l&rsquo;idea che non è affatto inusuale ritrovarsi a unire tra loro i propri repository contenenti attività isolate, risolvendo i conflitti incontrati nel corso di questo processo.)</para>
 
       &interaction.tour-merge-conflict.son;
 
 
       &interaction.tour-merge-conflict.pull;
 
-      <para id="x_35d">In questo esempio, imposterò la variabile d'ambiente <envar>HGMERGE</envar> per dire a Mercurial di usare il comando non interattivo <command>merge</command>. Questo comando è incluso in molti sistemi di tipo Unix. (Se state seguendo questo esempio sul vostro computer, non preoccupatevi di impostare <envar>HGMERGE</envar>. Vi verrà presentata un'applicazione grafica da utilizzare per unire i file, che è un'alternativa di gran lunga preferibile.)</para>
+      <para id="x_35d">In questo esempio, imposterò la variabile d&rsquo;ambiente <envar>HGMERGE</envar> per dire a Mercurial di usare il comando non interattivo <command>merge</command>. Questo comando è incluso in molti sistemi di tipo Unix. (Se state seguendo questo esempio sul vostro computer, non preoccupatevi di impostare <envar>HGMERGE</envar>. Vi verrà presentata un&rsquo;applicazione grafica da utilizzare per unire i file, che è un&rsquo;alternativa di gran lunga preferibile.)</para>
 
       &interaction.tour-merge-conflict.merge;
 
-      <para id="x_35f">Dato che <command>merge</command> non riesce a risolvere il conflitto tra i cambiamenti, inserisce alcuni <emphasis>marcatori di unione</emphasis> all'interno del file che esibisce i conflitti, per indicare quali righe sono in conflitto e se quelle righe provengono dalla nostra versione del file o dalla loro.</para>
+      <para id="x_35f">Dato che <command>merge</command> non riesce a risolvere il conflitto tra i cambiamenti, inserisce alcuni <emphasis>marcatori di unione</emphasis> all&rsquo;interno del file che esibisce i conflitti, per indicare quali righe sono in conflitto e se quelle righe provengono dalla nostra versione del file o dalla loro.</para>
 
-      <para id="x_360">Dal modo in cui <command>merge</command> termina, Mercurial riconosce che non è stato in grado di operare con successo, quindi ci dice quali comandi abbiamo bisogno di eseguire se vogliamo rifare l'operazione di unione. Questo potrebbe essere utile se, per esempio, stessimo lavorando con un'applicazione grafica per la gestione delle unioni e la chiudessimo perché siamo confusi o realizziamo di aver commesso un errore.</para>
+      <para id="x_360">Dal modo in cui <command>merge</command> termina, Mercurial riconosce che non è stato in grado di operare con successo, quindi ci dice quali comandi abbiamo bisogno di eseguire se vogliamo rifare l&rsquo;operazione di unione. Questo potrebbe essere utile se, per esempio, stessimo lavorando con un&rsquo;applicazione grafica per la gestione delle unioni e la chiudessimo perché siamo confusi o realizziamo di aver commesso un errore.</para>
 
-      <para id="x_361">Nel caso in cui l'unione automatica o manuale fallisca, nulla ci impedisce di <quote>correggere</quote> i file interessati per conto nostro, per poi inserire i risultati della nostra unione nel repository:</para>
+      <para id="x_361">Nel caso in cui l&rsquo;unione automatica o manuale fallisca, nulla ci impedisce di <quote>correggere</quote> i file interessati per conto nostro, per poi inserire i risultati della nostra unione nel repository:</para>
       
       &interaction.tour-merge-conflict.commit;
 
       <note>
-	<title>Dov'è il comando <command>hg resolve</command>?</title>
+	<title>Dov&rsquo;è il comando <command>hg resolve</command>?</title>
 
 	<para id="x_724">Il comando <command>hg resolve</command> è stato introdotto nella verisone 1.1 di Mercurial rilasciata nel dicembre 2008. Se state usando una versione più vecchia (eseguite <command>hg version</command> per controllare) questo comando non sarà presente. Nel caso la vostra versione di Mercurial sia precedente alla 1.1, vi consiglio vivamente di installare una versione più recente prima di affrontare unioni complicate.</para>
       </note>
     <programlisting>hg pull -u
 hg merge
 hg commit -m 'Incorporati i cambiamenti remoti'</programlisting>
-    <para id="x_363">Nel caso dell'inserimento finale, avete anche bisogno di includere un messaggio di commit, che sarà quasi sempre composto da testo <quote>standard</quote> non particolarmente interessante.</para>
+    <para id="x_363">Nel caso dell&rsquo;inserimento finale, avete anche bisogno di includere un messaggio di commit, che sarà quasi sempre composto da testo <quote>standard</quote> non particolarmente interessante.</para>
 
-    <para id="x_364">Se fosse possibile, sarebbe comodo ridurre il numero di passi necessari. In effetti, Mercurial viene distribuito con un'estensione chiamata <literal role="hg-ext">fetch</literal> pensata proprio per questo scopo.</para>
+    <para id="x_364">Se fosse possibile, sarebbe comodo ridurre il numero di passi necessari. In effetti, Mercurial viene distribuito con un&rsquo;estensione chiamata <literal role="hg-ext">fetch</literal> pensata proprio per questo scopo.</para>
 
     <para id="x_365">Mercurial fornisce un meccanismo flessibile per consentire ad altre persone di estendere le sue funzionalità, preservando le dimensioni ridotte e la manutenibilità del proprio nucleo. Alcune estensioni aggiungono nuovi comandi che potete usare dalla riga di comando, mentre altre lavorano <quote>dietro le quinte</quote>, per esempio accrescendo la funzionalità della modalità server predefinita di Mercurial.</para>
 
-    <para id="x_366">L'estensione <literal role="hg-ext">fetch</literal> aggiunge un nuovo comando chiamato, naturalmente, <command role="hg-cmd">hg fetch</command>. Questa estensione agisce come una combinazione di <command role="hg-cmd">hg pull -u</command>, <command role="hg-cmd">hg merge</command> e <command role="hg-cmd">hg commit</command>. Comincia propagando verso il repository corrente i cambiamenti estratti da un altro repository. Se si accorge che i cambiamenti hanno aggiunto una nuova testa al repository, aggiorna la directory di lavoro alla nuova testa, poi avvia il processo di unione e infine, se l'unione ha successo, ne inserisce il risultato nel repository con un messaggio di commit generato automaticamente. Se non sono state aggiunte nuove teste, il comando si limita ad aggiornare la directory di lavoro alla nuova revisione di punta.</para>
+    <para id="x_366">L&rsquo;estensione <literal role="hg-ext">fetch</literal> aggiunge un nuovo comando chiamato, naturalmente, <command role="hg-cmd">hg fetch</command>. Questa estensione agisce come una combinazione di <command role="hg-cmd">hg pull -u</command>, <command role="hg-cmd">hg merge</command> e <command role="hg-cmd">hg commit</command>. Comincia propagando verso il repository corrente i cambiamenti estratti da un altro repository. Se si accorge che i cambiamenti hanno aggiunto una nuova testa al repository, aggiorna la directory di lavoro alla nuova testa, poi avvia il processo di unione e infine, se l&rsquo;unione ha successo, ne inserisce il risultato nel repository con un messaggio di commit generato automaticamente. Se non sono state aggiunte nuove teste, il comando si limita ad aggiornare la directory di lavoro alla nuova revisione di punta.</para>
 
-    <para id="x_367">Abilitare l'estensione <literal role="hg-ext">fetch</literal> è facile. Aprite il file <filename role="special">.hgrc</filename> che si trova nella vostra directory personale e andate alla sezione <literal role="rc-extensions">extensions</literal> (oppure createla se non esiste già). Poi aggiungete una riga che contenga semplicemente <quote><literal>fetch=</literal></quote>.</para>
+    <para id="x_367">Abilitare l&rsquo;estensione <literal role="hg-ext">fetch</literal> è facile. Aprite il file <filename role="special">.hgrc</filename> che si trova nella vostra directory personale e andate alla sezione <literal role="rc-extensions">extensions</literal> (oppure createla se non esiste già). Poi aggiungete una riga che contenga semplicemente <quote><literal>fetch=</literal></quote>.</para>
 
     <programlisting>[extensions]
 fetch =</programlisting>
 
-    <para id="x_368">(Normalmente, la parte a destra del simbolo <quote><literal>=</literal></quote> indicherebbe dove trovare l'estensione, ma dato che l'estensione <literal role="hg-ext">fetch</literal> è compresa nella distribuzione standard, Mercurial sa già dove andarla a cercare.)</para>
+    <para id="x_368">(Normalmente, la parte a destra del simbolo <quote><literal>=</literal></quote> indicherebbe dove trovare l&rsquo;estensione, ma dato che l&rsquo;estensione <literal role="hg-ext">fetch</literal> è compresa nella distribuzione standard, Mercurial sa già dove andarla a cercare.)</para>
   </sect1>
 
   <sect1>
     <title>Rinominare, copiare e unire</title>
 
-    <para id="x_729">Durante la vita di un progetto, vorremo spesso cambiare la disposizione dei suoi file e delle sue directory. Queste modifiche possono essere tanto semplici quanto rinominare un singolo file, o tanto complesse quanto ristrutturare l'intera gerarchia dei file nell'ambito del progetto.</para>
+    <para id="x_729">Durante la vita di un progetto, vorremo spesso cambiare la disposizione dei suoi file e delle sue directory. Queste modifiche possono essere tanto semplici quanto rinominare un singolo file, o tanto complesse quanto ristrutturare l&rsquo;intera gerarchia dei file nell&rsquo;ambito del progetto.</para>
 
     <para id="x_72a">Mercurial supporta questi tipi di cambiamenti in maniera fluida, a patto che gli diciamo quello che stiamo facendo. Se vogliamo rinominare un file, dovremmo usare il comando <command>hg rename</command><footnote>
 	<para id="x_72b">Se siete utenti Unix, sarete felici di sapere che il comando <command>hg rename</command> si può abbreviare in <command>hg mv</command>.</para>
-    </footnote> per cambiare il nome del file, in modo che Mercurial possa comportarsi in maniera appropriata nel caso più tardi effettuassimo un'unione.</para>
+    </footnote> per cambiare il nome del file, in modo che Mercurial possa comportarsi in maniera appropriata nel caso più tardi effettuassimo un&rsquo;unione.</para>
 
-    <para id="x_72c">Tratteremo l'uso di questi comandi in maniera più estesa nella <xref linkend="chap:daily.copy"/>.</para>
+    <para id="x_72c">Tratteremo l&rsquo;uso di questi comandi in maniera più estesa nella <xref linkend="chap:daily.copy"/>.</para>
   </sect1>
 </chapter>

it/ch04-concepts.xml

 
   <para id="x_2e8">Diversamente da molti sistemi di controllo di revisione, Mercurial è costruito sulla base di concetti abbastanza semplici da facilitare la comprensione del modo in cui il software funziona realmente. Conoscere questi dettagli non è certamente necessario, per cui potete tranquillamente saltare questo capitolo. Tuttavia, penso che otterrete di più dal software conoscendo il <quote>modello concettuale</quote> del suo funzionamento.</para>
 
-  <para id="x_2e9">Essere in grado di capire quello che accade dietro le quinte mi dà una certa garanzia che Mercurial sia stato attentamente progettato per essere sia <emphasis>sicuro</emphasis> che <emphasis>efficiente</emphasis>. Analogamente, è importante che per me sia facile avere un'idea corretta di quello che il software sta facendo mentre svolgo un'attività di controllo di revisione, in modo da abbassare la probabilità di venire sorpreso dal suo comportamento.</para>
+  <para id="x_2e9">Essere in grado di capire quello che accade dietro le quinte mi dà una certa garanzia che Mercurial sia stato attentamente progettato per essere sia <emphasis>sicuro</emphasis> che <emphasis>efficiente</emphasis>. Analogamente, è importante che per me sia facile avere un&rsquo;idea corretta di quello che il software sta facendo mentre svolgo un&rsquo;attività di controllo di revisione, in modo da abbassare la probabilità di venire sorpreso dal suo comportamento.</para>
 
   <para id="x_2ea">Inizieremo questo capitolo parlando dei concetti chiave alla base della progettazione di Mercurial, poi proseguiremo discutendo alcuni dei dettagli più interessanti della sua implementazione.</para>
 
 
       <para id="x_2eb">Quando Mercurial tiene traccia delle modifiche a un file, memorizza la cronologia di quel file in un oggetto di metadati chiamato <emphasis>filelog</emphasis> (letteralmente, registro del file). Ogni voce in un filelog contiene informazioni sufficienti a ricostruire una revisione del file di cui tiene traccia. I filelog sono memorizzati come file nella directory <filename role="special" class="directory">.hg/store/data</filename>. Un filelog contiene due tipi di informazione: dati di revisione, più un indice per aiutare Mercurial a trovare una revisione in maniera efficiente.</para>
 
-      <para id="x_2ec">Il filelog di un file di grandi dimensioni o che abbia una lunga cronologia viene memorizzato in due file separati per i dati (con un suffisso <quote><literal>.d</literal></quote>) e l'indice (con un suffisso <quote><literal>.i</literal></quote>). Per file di piccole dimensioni con una cronologia ridotta, i dati di revisione e l'indice vengono combinati in un singolo file <quote><literal>.i</literal></quote>. La corrispondenza tra un file nella directory di lavoro e il filelog che tiene traccia della sua cronologia nel repository è illustrata nella <xref
+      <para id="x_2ec">Il filelog di un file di grandi dimensioni o che abbia una lunga cronologia viene memorizzato in due file separati per i dati (con un suffisso <quote><literal>.d</literal></quote>) e l&rsquo;indice (con un suffisso <quote><literal>.i</literal></quote>). Per file di piccole dimensioni con una cronologia ridotta, i dati di revisione e l&rsquo;indice vengono combinati in un singolo file <quote><literal>.i</literal></quote>. La corrispondenza tra un file nella directory di lavoro e il filelog che tiene traccia della sua cronologia nel repository è illustrata nella <xref
 	  linkend="fig:concepts:filelog"/>.</para>
 
       <figure id="fig:concepts:filelog">
     <sect2>
       <title>Relazioni tra le revisioni</title>
 
-      <para id="x_2f0">Nell'ambito di un changelog, di un manifest, o di un filelog, ogni revisione mantiene un puntatore al suo genitore diretto (o ai suoi due genitori, se è una revisione di unione). Come ho già detto, esistono anche relazioni tra revisioni <emphasis>attraverso</emphasis> queste strutture, e tali relazioni sono di natura gerarchica.</para>
+      <para id="x_2f0">Nell&rsquo;ambito di un changelog, di un manifest, o di un filelog, ogni revisione mantiene un puntatore al suo genitore diretto (o ai suoi due genitori, se è una revisione di unione). Come ho già detto, esistono anche relazioni tra revisioni <emphasis>attraverso</emphasis> queste strutture, e tali relazioni sono di natura gerarchica.</para>
 
       <para id="x_2f1">Per ogni changeset nel repository, esiste esattamente una revisione memorizzata nel changelog. Ogni revisione del changelog contiene un puntatore a una singola revisione del manifest. Una revisione del manifest include un puntatore a una singola revisione di ogni filelog registrato quando il changeset è stato creato. Queste relazioni sono illustrate nella <xref linkend="fig:concepts:metadata"/>.</para>
 
 	</mediaobject>
       </figure>
 
-      <para id="x_2f3">Come mostrato in figura, <emphasis>non</emphasis> c'è una relazione <quote>uno a uno</quote> tra le revisioni nel changelog, nel manifest, o nel filelog. Se un file registrato da Mercurial non è cambiato tra due changeset, la voce per quel file nelle due revisioni del manifest punterà alla stessa revisione nel suo filelog<footnote>
+      <para id="x_2f3">Come mostrato in figura, <emphasis>non</emphasis> c&rsquo;è una relazione <quote>uno a uno</quote> tra le revisioni nel changelog, nel manifest, o nel filelog. Se un file registrato da Mercurial non è cambiato tra due changeset, la voce per quel file nelle due revisioni del manifest punterà alla stessa revisione nel suo filelog<footnote>
 	  <para id="x_725">&Egrave; possibile (anche se inusuale) che il manifest rimanga lo stesso tra due changeset, nel qual caso le voci del changelog per quei changeset punteranno alla stessa revisione del manifest.</para>
 	</footnote>.</para>
 
     <sect2>
       <title>Memorizzazione efficiente</title>
 
-      <para id="x_2f5">Il revlog permette di memorizzare le revisioni in maniera efficiente usando un meccanismo basato su differenze chiamate <emphasis>delta</emphasis>. Invece di registrare una copia completa di un file per ogni revisione, il revlog memorizza i cambiamenti necessari a trasformare una revisione più vecchia nella nuova revisione. Per molti tipi di file, queste delta sono tipicamente una frazione percentuale della dimensione di un'intera copia di un file.</para>
+      <para id="x_2f5">Il revlog permette di memorizzare le revisioni in maniera efficiente usando un meccanismo basato su differenze chiamate <emphasis>delta</emphasis>. Invece di registrare una copia completa di un file per ogni revisione, il revlog memorizza i cambiamenti necessari a trasformare una revisione più vecchia nella nuova revisione. Per molti tipi di file, queste delta sono tipicamente una frazione percentuale della dimensione di un&rsquo;intera copia di un file.</para>
 
       <para id="x_2f6">Alcuni sistemi di controllo di revisione obsoleti possono lavorare solo con le delta di file di testo e sono costretti a memorizzare i file binari come copie complete o a codificarli in una rappresentazione testuale, entrambi approcci dispendiosi. Mercurial è in grado di gestire in maniera efficiente le delta di file con contenuti binari arbitrari, per cui non ha bisogno di trattare il testo in maniera speciale.</para>
 
 
       <para id="x_2f7">Mercurial si limita ad <emphasis>aggiungere</emphasis> dati alla fine di un file di revlog invece di modificarne una sezione dopo averlo memorizzato. Questo approccio è più robusto ed efficiente rispetto a sistemi che hanno bisogno di modificare o riscrivere i dati.</para>
 
-      <para id="x_2f8">In più, Mercurial tratta ogni scrittura come parte di una <emphasis>transazione</emphasis> che può coinvolgere un qualsiasi numero di file. Una transazione è <emphasis>atomica</emphasis>: o l'intera transazione ha successo e i suoi effetti sono visibili in lettura in un unico passo, oppure l'operazione viene completamente annullata. Questa garanzia di atomicità significa che se state eseguendo due copie di Mercurial, una che sta leggendo dati e l'altra che sta scrivendo, la copia che agisce in lettura non vedrà mai un risultato parzialmente scritto che potrebbe confonderla.</para>
+      <para id="x_2f8">In più, Mercurial tratta ogni scrittura come parte di una <emphasis>transazione</emphasis> che può coinvolgere un qualsiasi numero di file. Una transazione è <emphasis>atomica</emphasis>: o l&rsquo;intera transazione ha successo e i suoi effetti sono visibili in lettura in un unico passo, oppure l&rsquo;operazione viene completamente annullata. Questa garanzia di atomicità significa che se state eseguendo due copie di Mercurial, una che sta leggendo dati e l&rsquo;altra che sta scrivendo, la copia che agisce in lettura non vedrà mai un risultato parzialmente scritto che potrebbe confonderla.</para>
 
       <para id="x_2f9">Il fatto che Mercurial operi solo aggiungendo dati alla fine dei file rende più facile fornire questa garanzia transazionale. Più è facile fare cose come queste, più dovreste avere fiducia nel fatto che vengano eseguite correttamente.</para>
 
     <sect2>
       <title>Reperimento veloce</title>
 
-      <para id="x_2fa">Mercurial evita astutamente un'insidia comune a tutti i primi sistemi di controllo di revisione: il problema del <emphasis>reperimento inefficiente</emphasis>. La maggior parte dei sistemi di controllo di revisione memorizza i contenuti di una revisione come una serie incrementale di modifiche rispetto a una <quote>fotografia</quote>. (Alcuni basano la fotografia sulla revisione più vecchia, altri su quella più recente.) Per ricostruire una revisione specifica, dovete leggere prima la fotografia e poi ognuna delle revisioni tra la fotografia e la revisione che volete. Più cronologia accumula un file, più revisioni dovete leggere, quindi più tempo viene impiegato per ricostruire una particolare revisione.</para>
+      <para id="x_2fa">Mercurial evita astutamente un&rsquo;insidia comune a tutti i primi sistemi di controllo di revisione: il problema del <emphasis>reperimento inefficiente</emphasis>. La maggior parte dei sistemi di controllo di revisione memorizza i contenuti di una revisione come una serie incrementale di modifiche rispetto a una <quote>fotografia</quote>. (Alcuni basano la fotografia sulla revisione più vecchia, altri su quella più recente.) Per ricostruire una revisione specifica, dovete leggere prima la fotografia e poi ognuna delle revisioni tra la fotografia e la revisione che volete. Più cronologia accumula un file, più revisioni dovete leggere, quindi più tempo viene impiegato per ricostruire una particolare revisione.</para>
 
       <figure id="fig:concepts:snapshot">
 	<title>Fotografia di un revlog, con delta incrementali</title>
 	</mediaobject>
       </figure>
 
-      <para id="x_2fc">Il modo innovativo in cui Mercurial risolve questo problema è semplice ma efficace. Una volta che la quantità totale di informazioni di delta memorizzate dall'ultima fotografia supera una soglia fissata, Mercurial memorizza una nuova fotografia (compressa, naturalmente) invece di un'altra delta. Questo approccio consente di ricostruire velocemente <emphasis>qualsiasi</emphasis> revisione di un file e funziona così bene che in seguito è stato copiato da molti altri sistemi di controllo di revisione.</para>
+      <para id="x_2fc">Il modo innovativo in cui Mercurial risolve questo problema è semplice ma efficace. Una volta che la quantità totale di informazioni di delta memorizzate dall&rsquo;ultima fotografia supera una soglia fissata, Mercurial memorizza una nuova fotografia (compressa, naturalmente) invece di un&rsquo;altra delta. Questo approccio consente di ricostruire velocemente <emphasis>qualsiasi</emphasis> revisione di un file e funziona così bene che in seguito è stato copiato da molti altri sistemi di controllo di revisione.</para>
 
-      <para id="x_2fd">La <xref linkend="fig:concepts:snapshot"/> illustra l'idea. In una voce contenuta nel file indice di un revlog, Mercurial memorizza l'intervallo di voci che deve leggere dal file di dati per ricostruire una particolare revisione.</para>
+      <para id="x_2fd">La <xref linkend="fig:concepts:snapshot"/> illustra l&rsquo;idea. In una voce contenuta nel file indice di un revlog, Mercurial memorizza l&rsquo;intervallo di voci che deve leggere dal file di dati per ricostruire una particolare revisione.</para>
 
       <sect3>
-	<title>Digressione: l'influenza della compressione video</title>
+	<title>Digressione: l&rsquo;influenza della compressione video</title>
 
 	<para id="x_2fe">Se avete familiarità con la compressione video o avete mai esaminato un segnale televisivo trasmesso attraverso un cavo digitale o un servizio satellitare, potreste sapere che la maggior parte degli schemi per la compressione video memorizzano ogni frame del video come una delta rispetto al frame precedente.</para>
 
 
       <para id="x_301">Gli hash forniscono più di un semplice controllo contro la corruzione dei dati, infatti vengono usati come identificatori per le revisioni. Gli hash di identificazione dei changeset che avete visto come utenti finali provengono dalle revisioni del changelog. Sebbene anche i filelog e il manifest facciano uso di hash, in questo caso Mercurial li impiega solo dietro le quinte.</para>
 
-      <para id="x_302">Mercurial verifica che gli hash siano corretti nel momento in cui reperisce le revisioni dei file o estrae i cambiamenti da un altro repository. Se incontra un problema di integrità, lo segnalerà e bloccherà l'operazione che stava eseguendo.</para>
+      <para id="x_302">Mercurial verifica che gli hash siano corretti nel momento in cui reperisce le revisioni dei file o estrae i cambiamenti da un altro repository. Se incontra un problema di integrità, lo segnalerà e bloccherà l&rsquo;operazione che stava eseguendo.</para>
 
-      <para id="x_303">In aggiunta all'effetto che ha sull'efficienza del reperimento, l'uso di fotografie periodiche da parte di Mercurial rende i repository più robusti nei confronti della corruzione parziale dei dati. Se un revlog viene parzialmente rovinato da un errore hardware o da un bug di sistema, spesso rimane possibile ricostruire alcune o la maggior parte delle revisioni a partire dalle sezioni illese del revlog che si trovano prima e dopo la sezione rovinata. Questo non sarebbe possibile con un modello di memorizzazione basato unicamente sulle delta.</para>
+      <para id="x_303">In aggiunta all&rsquo;effetto che ha sull&rsquo;efficienza del reperimento, l&rsquo;uso di fotografie periodiche da parte di Mercurial rende i repository più robusti nei confronti della corruzione parziale dei dati. Se un revlog viene parzialmente rovinato da un errore hardware o da un bug di sistema, spesso rimane possibile ricostruire alcune o la maggior parte delle revisioni a partire dalle sezioni illese del revlog che si trovano prima e dopo la sezione rovinata. Questo non sarebbe possibile con un modello di memorizzazione basato unicamente sulle delta.</para>
     </sect2>
   </sect1>
 
   <sect1>
     <title>Cronologia delle revisioni, ramificazioni e unioni</title>
 
-    <para id="x_304">Ogni voce in un revlog di Mercurial conosce l'identità della propria revisione progenitrice diretta, di solito chiamata <emphasis>genitore</emphasis>. In effetti, una revisione contiene spazio non solo per un genitore, ma per due. Mercurial usa un hash speciale, chiamato <quote>identificatore nullo</quote>, per rappresentare l'idea che <quote>non c'è alcun genitore qui</quote>. Questo hash è semplicemente una stringa di zeri.</para>
+    <para id="x_304">Ogni voce in un revlog di Mercurial conosce l&rsquo;identità della propria revisione progenitrice diretta, di solito chiamata <emphasis>genitore</emphasis>. In effetti, una revisione contiene spazio non solo per un genitore, ma per due. Mercurial usa un hash speciale, chiamato <quote>identificatore nullo</quote>, per rappresentare l&rsquo;idea che <quote>non c&rsquo;è alcun genitore qui</quote>. Questo hash è semplicemente una stringa di zeri.</para>
 
     <para id="x_305">Nella <xref linkend="fig:concepts:revlog"/>, potete vedere un esempio della struttura concettuale di un revlog. I filelog, i manifest e i changelog hanno tutti questa identica struttura e differiscono solo per il tipo di dati memorizzati in ogni delta e fotografia.</para>
 
-    <para id="x_306">La prima revisione in un revlog (nella parte inferiore dell'immagine) presenta un identificatore nullo in entrambi gli spazi riservati ai genitori. Per una revisione <quote>normale</quote>, lo spazio del primo genitore contiene l'identificatore della revisione genitore e lo spazio del secondo contiene l'identificatore nullo, indicando che la revisione possiede un solo vero genitore. Due revisioni qualsiasi che possiedano lo stesso genitore si chiamano <emphasis>rami</emphasis>. Una revisione che rappresenta un'unione tra rami ha due identificatori di revisione normali negli spazi dedicati ai propri genitori.</para>
+    <para id="x_306">La prima revisione in un revlog (nella parte inferiore dell&rsquo;immagine) presenta un identificatore nullo in entrambi gli spazi riservati ai genitori. Per una revisione <quote>normale</quote>, lo spazio del primo genitore contiene l&rsquo;identificatore della revisione genitore e lo spazio del secondo contiene l&rsquo;identificatore nullo, indicando che la revisione possiede un solo vero genitore. Due revisioni qualsiasi che possiedano lo stesso genitore si chiamano <emphasis>rami</emphasis>. Una revisione che rappresenta un&rsquo;unione tra rami ha due identificatori di revisione normali negli spazi dedicati ai propri genitori.</para>
 
     <figure id="fig:concepts:revlog">
       <title>La struttura concettuale di un revlog</title>
 
     <para id="x_308">La directory di lavoro <quote>sa</quote> quale changeset contiene. Quando aggiornate la directory di lavoro per contenere un particolare changeset, Mercurial cerca la revisione appropriata del manifest per trovare quali file aveva registrato nel momento in cui quel changeset è stato inserito e qual era la revisione corrente di ogni file in quel momento. Poi, ricrea una copia di tutti quei file con gli stessi contenuti che avevano quando il changeset è stato inserito.</para>
 
-    <para id="x_309">Il <emphasis>dirstate</emphasis> (letteralmente, stato della directory) è una struttura speciale che contiene le informazioni possedute da Mercurial sulla directory di lavoro. Viene mantenuto sotto forma di un file chiamato <filename>.hg/dirstate</filename> all'interno di un repository. Il dirstate contiene i dettagli del changeset a cui la directory di lavoro è aggiornata e di tutti i file che Mercurial sta monitorando nella directory di lavoro. Il dirstate permette a Mercurial anche di notare velocemente i file modificati, registrando le loro date e dimensioni al momento dell'aggiornamento.</para>
+    <para id="x_309">Il <emphasis>dirstate</emphasis> (letteralmente, stato della directory) è una struttura speciale che contiene le informazioni possedute da Mercurial sulla directory di lavoro. Viene mantenuto sotto forma di un file chiamato <filename>.hg/dirstate</filename> all&rsquo;interno di un repository. Il dirstate contiene i dettagli del changeset a cui la directory di lavoro è aggiornata e di tutti i file che Mercurial sta monitorando nella directory di lavoro. Il dirstate permette a Mercurial anche di notare velocemente i file modificati, registrando le loro date e dimensioni al momento dell&rsquo;aggiornamento.</para>
 
-    <para id="x_30a">Il dirstate riserva spazio per due genitori, esattamente come una revisione di un revlog, in modo da poter rappresentare sia una normale revisione (con un genitore) che un'unione di due revisioni precedenti. Quando usate il comando <command role="hg-cmd">hg update</command>, il changeset a cui aggiornate la directory di lavoro viene memorizzato nello spazio del <quote>primo genitore</quote> e l'identificatore nullo nello spazio del secondo. Quando incorporate un altro changeset tramite <command role="hg-cmd">hg merge</command>, il primo genitore rimane lo stesso e il secondo genitore diventa il changeset che state incorporando. Il comando <command role="hg-cmd">hg parents</command> vi dice quali sono i genitori del dirstate.</para>
+    <para id="x_30a">Il dirstate riserva spazio per due genitori, esattamente come una revisione di un revlog, in modo da poter rappresentare sia una normale revisione (con un genitore) che un&rsquo;unione di due revisioni precedenti. Quando usate il comando <command role="hg-cmd">hg update</command>, il changeset a cui aggiornate la directory di lavoro viene memorizzato nello spazio del <quote>primo genitore</quote> e l&rsquo;identificatore nullo nello spazio del secondo. Quando incorporate un altro changeset tramite <command role="hg-cmd">hg merge</command>, il primo genitore rimane lo stesso e il secondo genitore diventa il changeset che state incorporando. Il comando <command role="hg-cmd">hg parents</command> vi dice quali sono i genitori del dirstate.</para>
 
     <sect2>
       <title>Cosa succede quando eseguite un commit</title>
 
       <para id="x_30f">&Egrave; utile pensare alla directory di lavoro come al <quote>changeset che state per inserire</quote>. Le azioni compiute su qualsiasi file che abbiate detto a Mercurial di aver aggiunto, rimosso, rinominato, o copiato verranno riflesse in quel changeset, così come le modifiche a qualsiasi file che Mercurial aveva già registrato. Il nuovo changeset acquisirà come propri genitori quelli della directory di lavoro.</para>
 
-      <para id="x_310">Dopo un commit, Mercurial aggiornerà i genitori della directory di lavoro in modo che il primo genitore sia l'identificatore del nuovo changeset e il secondo sia l'identificatore nullo, come mostrato nella <xref linkend="fig:concepts:wdir-after-commit"/>. Mercurial non tocca alcun file nella directory di lavoro quando eseguite un commit, ma si limita a modificare il dirstate per annotare i nuovi genitori della directory.</para>
+      <para id="x_310">Dopo un commit, Mercurial aggiornerà i genitori della directory di lavoro in modo che il primo genitore sia l&rsquo;identificatore del nuovo changeset e il secondo sia l&rsquo;identificatore nullo, come mostrato nella <xref linkend="fig:concepts:wdir-after-commit"/>. Mercurial non tocca alcun file nella directory di lavoro quando eseguite un commit, ma si limita a modificare il dirstate per annotare i nuovi genitori della directory.</para>
 
     </sect2>
     <sect2>
 	</mediaobject>
       </figure>
 
-      <para id="x_319">Mercurial deve anche modificare la directory di lavoro per unire i file gestiti dai due changeset. Semplificandolo un po', il processo di unione funziona nel modo seguente, per ogni file contenuto nei manifest di entrambi i changeset.</para>
+      <para id="x_319">Mercurial deve anche modificare la directory di lavoro per unire i file gestiti dai due changeset. Semplificandolo un po&rsquo;, il processo di unione funziona nel modo seguente, per ogni file contenuto nei manifest di entrambi i changeset.</para>
       <itemizedlist>
 	<listitem><para id="x_31a">Se nessuno dei changeset ha modificato il file, non fare nulla con quel file.</para>
 	</listitem>
-	<listitem><para id="x_31b">Se un changeset ha modificato il file e l'altro non lo ha modificato, crea la copia modificata del file nella directory di lavoro.</para>
+	<listitem><para id="x_31b">Se un changeset ha modificato il file e l&rsquo;altro non lo ha modificato, crea la copia modificata del file nella directory di lavoro.</para>
 	</listitem>
-	<listitem><para id="x_31c">Se un changeset ha rimosso un file e l'altro no (o se anche l'altro lo ha cancellato), cancella il file dalla directory di lavoro.</para>
+	<listitem><para id="x_31c">Se un changeset ha rimosso un file e l&rsquo;altro no (o se anche l&rsquo;altro lo ha cancellato), cancella il file dalla directory di lavoro.</para>
 	</listitem>
-	<listitem><para id="x_31d">Se un changeset ha cancellato un file ma l'altro lo ha modificato, chiedi all'utente cosa vuole fare: tenere il file modificato oppure rimuoverlo?</para>
+	<listitem><para id="x_31d">Se un changeset ha cancellato un file ma l&rsquo;altro lo ha modificato, chiedi all&rsquo;utente cosa vuole fare: tenere il file modificato oppure rimuoverlo?</para>
 	</listitem>
-	<listitem><para id="x_31e">Se entrambi i changeset hanno modificato un file, richiama un programma di unione esterno per scegliere i contenuti del file da unire. Questa operazione potrebbe richiedere un'interazione con l'utente.</para>
+	<listitem><para id="x_31e">Se entrambi i changeset hanno modificato un file, richiama un programma di unione esterno per scegliere i contenuti del file da unire. Questa operazione potrebbe richiedere un&rsquo;interazione con l&rsquo;utente.</para>
 	</listitem>
-	<listitem><para id="x_31f">Se un changeset ha modificato un file e l'altro lo ha rinominato o copiato, assicurati che i cambiamenti seguano il nuovo nome del file.</para>
+	<listitem><para id="x_31f">Se un changeset ha modificato un file e l&rsquo;altro lo ha rinominato o copiato, assicurati che i cambiamenti seguano il nuovo nome del file.</para>
 	</listitem></itemizedlist>
       <para id="x_320">Ci sono molti altri dettagli&emdash;le unioni sono piene di casi particolari&emdash;ma queste sono le scelte più comuni coinvolte nel processo di unione. Come potete vedere, la maggior parte dei casi è completamente automatizzata e in effetti la maggior parte delle unioni termina automaticamente senza richiedere il vostro intervento per risolvere alcun conflitto.</para>
 
-      <para id="x_321">Se considerate quello che succede quando effettuate un commit dopo un'unione, ancora una volta la directory di lavoro è <quote>il changeset che state per inserire</quote>. Dopo che il comando <command role="hg-cmd">hg merge</command> ha terminato, la directory di lavoro possiede due genitori, che poi diventeranno i genitori del nuovo changeset.</para>
+      <para id="x_321">Se considerate quello che succede quando effettuate un commit dopo un&rsquo;unione, ancora una volta la directory di lavoro è <quote>il changeset che state per inserire</quote>. Dopo che il comando <command role="hg-cmd">hg merge</command> ha terminato, la directory di lavoro possiede due genitori, che poi diventeranno i genitori del nuovo changeset.</para>
 
-      <para id="x_322">Mercurial vi permette di effettuare molteplici unioni, ma dovete inserire i risultati di ogni singola unione man mano che procedete, perché Mercurial tiene traccia solamente di due genitori sia per le revisioni che per la directory di lavoro. Anche se unire molteplici changeset alla volta sarebbe tecnicamente possibile, Mercurial evita di farlo per semplicità. Con unioni a più vie, il rischio di disorientare l'utente, di incappare in conflitti sgradevoli da risolvere e di fare una terribile confusione durante il processo di unione diventerebbe intollerabile.</para>
+      <para id="x_322">Mercurial vi permette di effettuare molteplici unioni, ma dovete inserire i risultati di ogni singola unione man mano che procedete, perché Mercurial tiene traccia solamente di due genitori sia per le revisioni che per la directory di lavoro. Anche se unire molteplici changeset alla volta sarebbe tecnicamente possibile, Mercurial evita di farlo per semplicità. Con unioni a più vie, il rischio di disorientare l&rsquo;utente, di incappare in conflitti sgradevoli da risolvere e di fare una terribile confusione durante il processo di unione diventerebbe intollerabile.</para>
 
     </sect2>
 
     <sect2>
       <title>Le unioni e i cambiamenti di nome</title>
 
-      <para id="x_69a">Un numero sorprendente di sistemi di controllo di revisione dedica poca o addirittura nessuna attenzione ai cambiamenti del <emphasis>nome</emphasis> di un file. Per esempio, era pratica comune scartare silenziosamente le modifiche a un file contenute in una delle due parti di un'unione se quel file fosse stato rinominato nell'altra parte.</para>
+      <para id="x_69a">Un numero sorprendente di sistemi di controllo di revisione dedica poca o addirittura nessuna attenzione ai cambiamenti del <emphasis>nome</emphasis> di un file. Per esempio, era pratica comune scartare silenziosamente le modifiche a un file contenute in una delle due parti di un&rsquo;unione se quel file fosse stato rinominato nell&rsquo;altra parte.</para>
 
       <para id="x_69b">Mercurial registra alcuni metadati quando gli dite di effettuare una cambiamento di nome o una copia e li usa durante le unioni per comportarsi in maniera appropriata. Per esempio, se io cambio il nome di un file che voi modificate senza rinominare, quando uniamo i nostri cambiamenti il file verrà rinominato e gli verranno applicate le vostre modifiche.</para>
     </sect2>
   <sect1>
     <title>Altre caratteristiche di progettazione interessanti</title>
 
-    <para id="x_323">Nelle sezioni precedenti, ho provato a evidenziare alcuni degli aspetti più importanti nella progettazione di Mercurial, per illustrare come sia stata dedicata la dovuta attenzione a prestazioni e affidabilità. Tuttavia, l'attenzione ai dettagli non finisce qui. Ci sono un certo numero di altri aspetti nella costruzione di Mercurial che trovo personalmente interessanti. Ne descriverò alcuni in questa sezione, separatamente dagli elementi <quote>di primo piano</quote> analizzati finora, in modo che se siete interessati potete farvi un'idea più precisa di quanti ragionamenti ci sono dietro a un sistema ben progettato.</para>
+    <para id="x_323">Nelle sezioni precedenti, ho provato a evidenziare alcuni degli aspetti più importanti nella progettazione di Mercurial, per illustrare come sia stata dedicata la dovuta attenzione a prestazioni e affidabilità. Tuttavia, l&rsquo;attenzione ai dettagli non finisce qui. Ci sono un certo numero di altri aspetti nella costruzione di Mercurial che trovo personalmente interessanti. Ne descriverò alcuni in questa sezione, separatamente dagli elementi <quote>di primo piano</quote> analizzati finora, in modo che se siete interessati potete farvi un&rsquo;idea più precisa di quanti ragionamenti ci sono dietro a un sistema ben progettato.</para>
 
     <sect2>
       <title>Compressione intelligente</title>
 
       <para id="x_324">Quando è appropriato, Mercurial memorizzerà sia la fotografia che le delta in forma compressa, <emphasis>cercando</emphasis> sempre di comprimere una fotografia o una delta, ma memorizzando la versione compressa solo se è più piccola della versione originale.</para>
 
-      <para id="x_325">Questo significa che Mercurial fa <quote>la cosa giusta</quote> quando memorizza un file il cui formato sia già compresso, come un archivio <literal>zip</literal> o un'immagine JPEG. Quando questi tipi di file vengono compressi una seconda volta, il file risultante è tipicamente più grande di quello originale, così Mercurial memorizzerà la versione iniziale del file <literal>zip</literal> o JPEG.</para>
+      <para id="x_325">Questo significa che Mercurial fa <quote>la cosa giusta</quote> quando memorizza un file il cui formato sia già compresso, come un archivio <literal>zip</literal> o un&rsquo;immagine JPEG. Quando questi tipi di file vengono compressi una seconda volta, il file risultante è tipicamente più grande di quello originale, così Mercurial memorizzerà la versione iniziale del file <literal>zip</literal> o JPEG.</para>
 
       <para id="x_326">Di solito, le delta tra le revisioni di un file compresso sono più grandi delle fotografie del file, ma anche in questi casi Mercurial fa <quote>la cosa giusta</quote> ancora una volta. Scopre che quella delta supera la soglia oltre la quale Mercurial dovrebbe registrare una fotografia completa del file e quindi memorizza la fotografia, risparmiando ancora spazio nei confronti di un approccio ingenuo basato solo sulle delta.</para>
 
       <sect3>
 	<title>Ricompressione di rete</title>
 
-	<para id="x_327">Nel memorizzare le revisioni su disco, Mercurial usa l'algoritmo di compressione <quote>deflate</quote> (lo stesso usato dal popolare formato <literal>zip</literal>), che concilia una buona velocità con un rispettabile rapporto di compressione. Tuttavia, quando trasmette i dati di una revisione attraverso una connessione di rete, Mercurial decomprime i dati di revisione compressi.</para>
+	<para id="x_327">Nel memorizzare le revisioni su disco, Mercurial usa l&rsquo;algoritmo di compressione <quote>deflate</quote> (lo stesso usato dal popolare formato <literal>zip</literal>), che concilia una buona velocità con un rispettabile rapporto di compressione. Tuttavia, quando trasmette i dati di una revisione attraverso una connessione di rete, Mercurial decomprime i dati di revisione compressi.</para>
 
-	<para id="x_328">Se la connessione avviene via HTTP, Mercurial ricomprime l'intero flusso di dati usando un algoritmo che ha un rapporto di compressione migliore (l'algoritmo Burrows-Wheeler del rinomato pacchetto di compressione <literal>bzip2</literal>). Questa combinazione di algoritmo e compressione dell'intero flusso (invece di una revisione alla volta) riduce notevolmente il numero di byte da trasferire, producendo prestazioni di trasmissione migliori sulla maggior parte delle reti.</para>
+	<