Romain Pelisse avatar Romain Pelisse committed 713f0f6

merge with Italian, and very (few) work on ch03

Comments (0)

Files changed (293)

 en/examples/results
 en/html
 en/svn
+it/examples/results
+it/html
 stylesheets/system-xsl
 tools
 web/hgbook/.database.sqlite3
 18131160f7ee3b81bf39ce2c58f762b8d671cef3 submitted
+94d2205f02e7c47931db382a3a80553ef01b3913 1st-edition-it

fr/ch03-tour-merge.xml

 <!-- vim: set filetype=docbkxml shiftwidth=2 autoindent expandtab tw=77 : -->
 
-<chapter>
-<title>Un rapide tour de Mercurial: fusionner les travaux</title>
-<para>\label{chap:tour-merge}</para>
+<chapter id="chap:tour-merge">
+  <?dbhtml filename="a-tour-of-mercurial-merging-work.html"?>
+  <title>Un rapide tour de Mercurial: fusionner les travaux</title>
+  
+  <para id="x_338">Nous avons maintenant étudié comment cloner un dépôt, effectuer
+    des changements dedans, et récupérer ou transférer depuis un
+    autre dépôt. La prochaine étape est donc de <emphasis>fusionner</emphasis> les
+    modifications de différents dépôts.</para>
 
-<para>Nous avons maintenant étudié comment cloner un dépôt, effectuer
-des changements dedans, et récupérer ou transférer depuis un
-autre dépôt. La prochaine étape est donc de <emphasis>fusionner</emphasis> les
-modifications de différents dépôts.</para>
+  <sect1>
+    <title>Fusionner différents travaux</title>
+      <para od="x_339">La fusion  est un aspect fondamental lorsqu'on
+      travaille iavec un gestionnaire de source distribué.</para>
 
-<sect1>
-<title>Fusionner différents travaux</title>
-<para>				       %%% for 'Merging streams of work' ?
-La fusion\footnote{NdT: Je garde fusion mais le jargon professionnel
-emploiera généralement le terme \textit{merge}.} est un aspect
-fondamental lorsqu'on travaille avec un gestionnaire de source
-distribué.</para>
-<itemizedlist>
-<listitem><para>Alice et Bob ont chacun une copie personnelle du dépôt d'un
+      <itemizedlist>
+        <listitem><para>Alice et Bob ont chacun une copie personnelle du dépôt d'un
   projet sur lequel ils collaborent. Alice corrige un \textit{bug}
   dans son dépôt, et Bob ajoute une nouvelle fonctionnalité dans le
   sien. Ils veulent un dépôt partagé avec à la fois le correctif du
 local variables: 
 sgml-parent-document: ("00book.xml" "book" "chapter")
 end:
--->
+-->
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.5//EN"
+ "http://www.oasis-open.org/docbook/xml/4.5/docbookx.dtd"
+[
+<!-- Below are references to files in this directory. -->
+
+<!-- Chapters. -->
+
+<!ENTITY ch00     SYSTEM "ch00-preface.xml">
+<!ENTITY ch01     SYSTEM "ch01-intro.xml">
+<!ENTITY ch02     SYSTEM "ch02-tour-basic.xml">
+<!ENTITY ch03     SYSTEM "ch03-tour-merge.xml">
+<!ENTITY ch04     SYSTEM "ch04-concepts.xml">
+<!ENTITY ch05     SYSTEM "ch05-daily.xml">
+<!ENTITY ch06     SYSTEM "ch06-collab.xml">
+<!ENTITY ch07     SYSTEM "ch07-filenames.xml">
+<!ENTITY ch08     SYSTEM "ch08-branch.xml">
+<!ENTITY ch09     SYSTEM "ch09-undo.xml">
+<!ENTITY ch10     SYSTEM "ch10-hook.xml">
+<!ENTITY ch11     SYSTEM "ch11-template.xml">
+<!ENTITY ch12     SYSTEM "ch12-mq.xml">
+<!ENTITY ch13     SYSTEM "ch13-mq-collab.xml">
+<!ENTITY ch14     SYSTEM "ch14-hgext.xml">
+<!ENTITY appA     SYSTEM "appA-svn.xml">
+<!ENTITY appB     SYSTEM "appB-mq-ref.xml">
+<!ENTITY appC     SYSTEM "appC-srcinstall.xml">
+<!ENTITY appD     SYSTEM "appD-license.xml">
+<!ENTITY bib      SYSTEM "bibliography.xml">
+
+<!-- Include our standard shortcuts. -->
+
+<!ENTITY % SHORTCUTS SYSTEM "book-shortcuts.xml">
+%SHORTCUTS;
+
+<!-- Include automatically and manually generated code snippets. -->
+
+<!ENTITY % AUTOSNIPPETS SYSTEM "examples/auto-snippets.xml">
+%AUTOSNIPPETS;
+
+]>
+
+<book id="hg">
+  <title>Mercurial: la guida definitiva</title>
+  
+  <!-- hg parents &#x2d;&#x2d;template '{node|short} ({date|shortdate})' 
+  <subtitle>Compiled from 8a1d3f1aff17 (2009-03-10)</subtitle>
+  -->
+  <subtitle>Compiled from $rev_id$</subtitle>
+  <bookinfo>
+    <edition>1</edition>
+    <isbn>9780596800673</isbn>
+    <authorgroup>
+      <author>
+        <firstname>Bryan</firstname>
+        <surname>O'Sullivan</surname>
+      </author>
+    </authorgroup>
+
+    <editor>
+      <firstname>Mike</firstname>
+      <surname>Loukides</surname>
+    </editor>
+
+    <copyright>
+      <year>2006</year>
+      <year>2007</year>
+      <year>2008</year>
+      <year>2009</year>
+      <holder>Bryan O'Sullivan</holder>
+    </copyright>
+    
+    <othercredit class="translator">
+      <firstname>Giulio</firstname>
+      <surname>Piancastelli</surname>
+    </othercredit>
+    
+    <copyright>
+      <year>2009</year>
+      <holder>Giulio Piancastelli</holder>
+    </copyright>
+  </bookinfo>
+
+  <!-- BEGIN ch00 -->
+  &ch00;
+  <!-- BEGIN ch01 -->
+  &ch01;
+  <!-- BEGIN ch02 -->
+  &ch02;
+  <!-- BEGIN ch03 -->
+  &ch03;
+  <!-- BEGIN ch04 -->
+  &ch04;
+  <!-- BEGIN ch05 -->
+  &ch05;
+  <!-- BEGIN ch06 -->
+  &ch06;
+  <!-- BEGIN ch07 -->
+  &ch07;
+  <!-- BEGIN ch08 -->
+  &ch08;
+  <!-- BEGIN ch09 -->
+  &ch09;
+  <!-- BEGIN ch10 -->
+  &ch10;
+  <!-- BEGIN ch11 -->
+  &ch11;
+  <!-- BEGIN ch12 -->
+  &ch12;
+  <!-- BEGIN ch13 -->
+  &ch13;
+  <!-- BEGIN ch14 -->
+  &ch14;
+  <!-- BEGIN appA -->
+  &appA;
+  <!-- BEGIN appB -->
+  &appB;
+  <!-- BEGIN appC -->
+  &appC;
+  <!-- BEGIN appD -->
+  &appD;
+  <!-- BEGIN bib -->
+  &bib;
+</book>
+include Makefile.vars
+
+# Makefile.vars includes the following system-dependent variables:
+#
+# dtd-url = the location of the DocBook 4.5 DTD on your filesystem
+# system-xsl-dir = the location of DocBook XSLT on your filesystem
+# dynamic-link-command = the command to link the DocBook XSLT to our styles 
+# python = the location of Python 3.x on your filesystem
+
+xml-src-files := \
+	00book.xml \
+	$(wildcard ch*.xml) \
+	$(wildcard app*.xml) \
+	bibliography.xml
+
+xsltproc-opts := --nonet --xinclude
+xmllint-opts := --noout --nonet --valid --path '$(dtd-url)'
+
+root-web := html
+support-web := $(root-web)/support
+obj-web := $(root-web)/read
+figs-web-folder := $(obj-web)/figs
+script-web := $(obj-web)/javascript
+web-global := ../web
+web-local := web
+
+html: $(obj-web)/index.html $(web-local)/index-read.html.in figs
+
+$(obj-web)/index.html: ../stylesheets/system-xsl .validated-00book.xml
+	xsltproc $(xsltproc-opts) -o $(obj-web)/x ../stylesheets/it/web.xsl 00book.xml
+	mkdir -p $(support-web)
+	cp -f $(web-global)/icons/*.png $(support-web)
+	cp $(web-global)/styles.css $(support-web)
+	sed -i -e "s|figs/||g" $(support-web)/styles.css
+	mkdir -p $(figs-web-folder)
+	mkdir -p $(script-web)
+	cp -f $(web-local)/*.js $(script-web)
+
+../stylesheets/system-xsl: $(system-xsl-dir)
+	$(dynamic-link-command)
+
+$(web-local)/index-read.html.in: $(web-local)/genindex.py $(xml-src-files)
+	cp $(web-local)/index-template.html $(obj-web)/index.html
+	sed -i -e "s|{% block bodycontent %}{% endblock %}|$(shell cat $(web-local)/index-read.html.in)|g" $(obj-web)/index.html
+	sed -i -e "s|/support/|../support/|g" $(obj-web)/*.html
+	cp $(web-local)/index-template.html $(root-web)/index.html
+	sed -i "s|{% block bodycontent %}{% endblock %}|$(shell cat $(web-local)/index-home.html.in)|g" $(root-web)/index.html
+	sed -i -e "s|/support/|support/|g" $(root-web)/index.html
+
+$(web-local)/genindex.py: $(xml-src-files)
+	cd $(web-local) && $(python) genindex.py
+
+valid: .validated-00book.xml
+
+.validated-00book.xml: $(xml-src-files)
+	xmllint $(xmllint-opts) $<
+	touch $@
+
+clean:
+	rm -f $(web-local)/index-read.html.in
+	rm -f .validated-00book.xml
+	rm -rf $(root-web)
+
+image-folder := figs
+# graphs, figures, screenshots
+image-files := $(wildcard $(image-folder)/*.dot $(image-folder)/*.svg $(image-folder)/*.png)
+# graphs
+image-dot := $(filter %.dot, $(image-files))
+# figures
+image-svg := $(filter %.svg, $(image-files))
+# screenshots
+image-png := $(filter %.png, $(image-files))
+
+figs-web := \
+	$(image-dot:$(image-folder)/%.dot=$(figs-web-folder)/%.png) \
+	$(image-svg:$(image-folder)/%.svg=$(figs-web-folder)/%.png) \
+	$(image-png:$(image-folder)/%.png=$(figs-web-folder)/%.png)
+
+figs: $(figs-web)
+
+$(figs-web-folder)/%.png: $(image-folder)/%.svg
+	inkscape -D -d 120 -e $@ $<
+
+$(figs-web-folder)/%.png: $(figs-web-folder)/%.svg
+	inkscape -D -e $@ $<
+	rm $<
+
+$(figs-web-folder)/%.png: $(image-folder)/%.png
+	cp $< $@
+
+$(figs-web-folder)/%.svg: $(image-folder)/%.dot
+	dot -Tsvg -o $@ $<
+This is the Italian translation of "Mercurial: The Definitive Guide". The
+original book has been written by Bryan O'Sullivan and published by O'Reilly
+Media in 2009. The book has been translated into Italian by Giulio Piancastelli
+and currently is available in electronic form only.
+
+This book is written in DocBook and uses a variety of tools to produce a
+bunch of HTML pages to be published on a web site. Transformations towards a
+single HTML page or a PDF document are also possible, but are currently not
+directly supported.
+
+The tools needed to build the book are:
+
+ * DocBook XML DTD, version 4.5 (untested with a different version)
+ * DocBook XSL stylesheets, version >1.75.2 (see later)
+ * libxml2-utils, containing xmllint (used to validate the XML chapters against
+   the DocBook DTD) and xmlproc (used to transform XML to HTML)
+ * Graphviz, to transform DOT files (textual representations of graphs, yay)
+   into SVG images
+ * Inkscape, to transform SVG images into PNG images
+ * Python 3 (ah, yes, I'm sorry, see later), to generate a proper TOC
+
+(Apparently, if you want also to generate a PDF document out of the DocBook
+sources, the suggested tools are Java, Saxon, and FOP. You're still on your
+own here.)
+
+Once you have your tools properly installed, just type
+
+  $ make html
+
+and you should be set. First, the book is validated; then, XML is transformed
+into HTML; using the Mercurial repository, a Python 3 script generates a proper
+table of contents for the book; finally, images are transformed, and voilà, you
+have your own multi-page HTML version of the book. No other moving parts here.
+
+Now, let me briefly explain the two esoteric requirements about DocBook XSL and
+Python 3. First, the XSL stylesheets. As of today (23th August, 2009) the
+latest release of the DocBook XSL stylesheets is 1.75.2. So why I ask you to
+grab a release that doesn't even exist yet? Because the latest development
+snapshot includes a patch that allows an Italian writer to use complex
+prepositions in front of xrefs to sections. Without that patch, you will end up
+with text like "come abbiamo visto nella <a href=...>la sezione ...</a>", which
+is frankly unreadable. And you do want to read your newly generated version of
+the book, don't you? So, grab a DocBook XSL stylesheet development snapshot
+while waiting for 1.75.3 to be released, and have a go with it.
+
+Well, and what about Python 3? I'm sorry. I like it, I just happen to be a fan,
+so I'm using it everywhere I can, including this book. You can use it, too.
+The only Python script in the build system is it/web/genindex.py; anyway, it
+should not be that difficult to edit in order to let it run on Python 2, if you
+can't or don't want to use Python 3. Actually, my genindex.py is the result of
+converting Bryan's genindex.py to Python 3... but you can't use that script
+directly, because it contains some HTML text that I translated into Italian,
+and is not capable to make the References appear into the main TOC.
+
+WINDOWS USERS BEWARE!
+
+If you are building the book on a Windows system, good luck. I have written
+the entire translation on a Windows 2000 box (uh, yes, it's 2009 and they still
+exist) so I know how much the process can hurt. Thus, some words of advice
+follow.
+
+First, the silent assumption of the build script is that you are on a Linux (or
+probably just Unix-like) system. The build script is a Makefile, and uses
+typical *nix tools such as cat and sed. On Windows, you really need to have
+Cygwin installed. Look at the Makefile to know exactly which commands are used.
+
+Then, XSL transformations work on the basis of a symlink. ln -s. Yes. I know.
+How the fuck are you supposed to do that on Windows? (Well, at least Windows
+2000 and XP... I heard that newer versions should finally have that kind of
+feature built-in.) Two words: junction points. Oh, and an acronym: NTFS.
+Junction points are the equivalent of *nix symbolic links for directories
+under Windows, but they only work on NTFS. If you have a FAT32 file system,
+I believe you are screwed.
+
+More informations on junction points are available here:
+
+  http://technet.microsoft.com/en-us/sysinternals/bb896768.aspx
+
+Finally, Inkscape on the Windows command line has some limitations. You might
+be forced to pass absolute pathnames to images, use the program from its
+installation directory, or perform other esoteric contortions in order to have
+it run properly.
+
+PLEASE SEND FEEDBACK. I'm willing to update build informations and do (or just
+merge) some changes to the Makefile in order to improve the build process or
+expand it (e.g. to generate also a PDF output). I can be reached by email:
+
+  Giulio Piancastelli <giulio.piancastelli@gmail.com>
+
+<appendix id="chap:svn">
+  <?dbhtml filename="migrare-verso-mercurial.html"?>
+<title>Migrare verso Mercurial</title>
+
+  <para id="x_6e1">Un modo comune di esplorare un nuovo strumento di controllo di revisione è quello di sperimentarlo trasferendo un progetto esistente piuttosto che cominciare un nuovo progetto da zero.</para>
+
+  <para id="x_6e2">In questa appendice, parleremo di come importare la cronologia di un progetto in Mercurial e di quello a cui dovete essere preparati se siete abituati a un sistema di controllo di revisione differente.</para>
+
+  <sect1>
+    <title>Importare la cronologia da un altro sistema</title>
+
+    <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>
+      </listitem>
+      <listitem>
+	<para id="x_6e5">CVS</para>
+      </listitem>
+      <listitem>
+	<para id="x_6e6">git</para>
+      </listitem>
+      <listitem>
+	<para id="x_6e7">Darcs</para>
+      </listitem>
+      <listitem>
+	<para id="x_6e8">Bazaar</para>
+      </listitem>
+      <listitem>
+	<para id="x_6e9">Monotone</para>
+      </listitem>
+      <listitem>
+	<para id="x_6ea">GNU Arch</para>
+      </listitem>
+      <listitem>
+	<para id="x_6eb">Mercurial</para>
+      </listitem>
+    </itemizedlist>
+
+    <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&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&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&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&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&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&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&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&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>
+
+      <para id="x_6f2">Ogni volta che <literal>convert</literal> incontra un commit associato al nome utente <literal>arist</literal> nel repository sorgente, userà il nome <literal>Aristotele &lt;aristotele@filo.example.gr&gt;</literal> nella revisione convertita in Mercurial. Se non viene trovata alcuna corrispondenza per un certo nome, quel nome viene usato alla lettera.</para>
+    </sect2>
+
+    <sect2 id="svn.filemap">
+      <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&rsquo;intera gerarchia che ha bisogno di essere riorganizzata.</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&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
+
+include percorso/del/file
+
+exclude percorso/del/file
+
+rename da/qualche/percorso a/qualche/altra/posizione
+</programlisting>
+
+      <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&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>
+      <title>Migliorare le prestazioni della conversione da Subversion</title>
+
+      <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&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>svnadmin create memcached-mirror</userinput></screen>
+
+      <para id="x_70e">Successivamente, impostiamo un hook Subversion di cui <command>svnsync</command> ha bisogno.</para>
+
+      <screen><prompt>$</prompt> <userinput>echo '#!/bin/sh' > memcached-mirror/hooks/pre-revprop-change</userinput>
+<prompt>$</prompt> <userinput>chmod +x memcached-mirror/hooks/pre-revprop-change</userinput></screen>
+
+      <para id="x_70f">Poi inizializziamo <command>svnsync</command> in questo repository.</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&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_711">Infine, importiamo la cronologia del nostro mirror locale del repository Subversion in un repository Mercurial.</para>
+
+      <screen><prompt>$</prompt> <userinput>hg convert 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&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>
+
+  <sect1>
+    <title>Migrare da Subversion</title>
+
+    <para id="x_6f8">Attualmente Subversion è il sistema di controllo di revisione open source più popolare. Sebbene ci siano molte differenze tra Mercurial e Subversion, effettuare una transizione da Subversion a Mercurial non è particolarmente difficile. I due sistemi hanno insiemi di comandi simili e interfacce generalmente uniformi.</para>
+
+    <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&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&rsquo;unità della gestione dei rami.</para>
+
+      <sect3>
+	<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&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&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>
+
+      <sect3>
+	<title>Operazioni multi-utente e sicurezza</title>
+
+	<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&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>
+
+      <sect3>
+	<title>Cambiamenti locali o pubblici</title>
+
+	<para id="x_701">Il comando <command>svn commit</command> pubblica immediatamente i cambiamenti su un server dove possono essere visti da chiunque abbia accesso in lettura.</para>
+
+	<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&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&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>
+
+    <sect2>
+      <title>Guida rapida</title>
+
+      <table>
+	<title>Equivalenze tra i comandi Subversion e Mercurial</title>
+	<tgroup cols="3">
+	  <thead>
+	    <row>
+	      <entry>Subversion</entry>
+	      <entry>Mercurial</entry>
+	      <entry>Notes</entry>
+	    </row>
+	  </thead>
+	  <tbody>
+	    <row>
+	      <entry><command>svn add</command></entry>
+	      <entry><command>hg add</command></entry>
+	      <entry></entry>
+	    </row>
+	    <row>
+	      <entry><command>svn blame</command></entry>
+	      <entry><command>hg annotate</command></entry>
+	      <entry></entry>
+	    </row>
+	    <row>
+	      <entry><command>svn cat</command></entry>
+	      <entry><command>hg cat</command></entry>
+	      <entry></entry>
+	    </row>
+	    <row>
+	      <entry><command>svn checkout</command></entry>
+	      <entry><command>hg clone</command></entry>
+	      <entry></entry>
+	    </row>
+	    <row>
+	      <entry><command>svn cleanup</command></entry>
+	      <entry>n/a</entry>
+	      <entry>Nessuna pulizia necessaria</entry>
+	    </row>
+	    <row>
+	      <entry><command>svn commit</command></entry>
+	      <entry><command>hg commit</command>; <command>hg
+		  push</command></entry>
+	      <entry><command>hg push</command> pubblica le modifiche dopo il commit</entry>
+	    </row>
+	    <row>
+	      <entry><command>svn copy</command></entry>
+	      <entry><command>hg clone</command></entry>
+	      <entry>Per creare un nuovo ramo</entry>
+	    </row>
+	    <row>
+	      <entry><command>svn copy</command></entry>
+	      <entry><command>hg copy</command></entry>
+	      <entry>Per copiare file o directory</entry>
+	    </row>
+	    <row>
+	      <entry><command>svn delete</command> (<command>svn
+		  remove</command>)</entry>
+	      <entry><command>hg remove</command></entry>
+	      <entry></entry>
+	    </row>
+	    <row>
+	      <entry><command>svn diff</command></entry>
+	      <entry><command>hg diff</command></entry>
+	      <entry></entry>
+	    </row>
+	    <row>
+	      <entry><command>svn export</command></entry>
+	      <entry><command>hg archive</command></entry>
+	      <entry></entry>
+	    </row>
+	    <row>
+	      <entry><command>svn help</command></entry>
+	      <entry><command>hg help</command></entry>
+	      <entry></entry>
+	    </row>
+	    <row>
+	      <entry><command>svn import</command></entry>
+	      <entry><command>hg addremove</command>; <command>hg
+		  commit</command></entry>
+	      <entry></entry>
+	    </row>
+	    <row>
+	      <entry><command>svn info</command></entry>
+	      <entry><command>hg parents</command></entry>
+	      <entry>Mostra quale revisione è stata estratta</entry>
+	    </row>
+	    <row>
+	      <entry><command>svn info</command></entry>
+	      <entry><command>hg showconfig
+		  paths.parent</command></entry>
+	      <entry>Mostra da quale URL è avvenuta l&rsquo;estrazione</entry>
+	    </row>
+	    <row>
+	      <entry><command>svn list</command></entry>
+	      <entry><command>hg manifest</command></entry>
+	      <entry></entry>
+	    </row>
+	    <row>
+	      <entry><command>svn log</command></entry>
+	      <entry><command>hg log</command></entry>
+	      <entry></entry>
+	    </row>
+	    <row>
+	      <entry><command>svn merge</command></entry>
+	      <entry><command>hg merge</command></entry>
+	      <entry></entry>
+	    </row>
+	    <row>
+	      <entry><command>svn mkdir</command></entry>
+	      <entry>n/a</entry>
+	      <entry>Mercurial non tiene traccia delle directory</entry>
+	    </row>
+	    <row>
+	      <entry><command>svn move</command> (<command>svn
+		  rename</command>)</entry>
+	      <entry><command>hg rename</command></entry>
+	      <entry></entry>
+	    </row>
+	    <row>
+	      <entry><command>svn resolved</command></entry>
+	      <entry><command>hg resolve -m</command></entry>
+	      <entry></entry>
+	    </row>
+	    <row>
+	      <entry><command>svn revert</command></entry>
+	      <entry><command>hg revert</command></entry>
+	      <entry></entry>
+	    </row>
+	    <row>
+	      <entry><command>svn status</command></entry>
+	      <entry><command>hg status</command></entry>
+	      <entry></entry>
+	    </row>
+	    <row>
+	      <entry><command>svn update</command></entry>
+	      <entry><command>hg pull -u</command></entry>
+	      <entry></entry>
+	    </row>
+	  </tbody>
+	</tgroup>
+      </table>
+    </sect2>
+  </sect1>
+
+  <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&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&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>
+</appendix>

it/appB-mq-ref.xml

+<appendix id="chap:mqref">
+  <?dbhtml filename="guida-di-riferimento-di-mercurial-queues.html"?>
+  <title>Guida di riferimento a Mercurial Queues</title>
+
+  <sect1 id="sec:mqref:cmdref">
+    <title>Guida di riferimento ai comandi MQ</title>
+
+    <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&rsquo;ultima patch nella lista è quella <quote>in cima</quote> alla pila.</para>
+
+    </sect2>
+    <sect2>
+      <title><command role="hg-ext-mq">qcommit</command>&emdash;registra i cambiamenti nel repository della coda</title>
+
+      <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&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&rsquo;opzione <option role="hg-ext-mq-cmd-qdel-opt">-f</option> se volete fare questo.</para>
+
+      <para id="x_5ed">Opzioni:</para>
+      <itemizedlist>
+	<listitem><para id="x_5ee"><option role="hg-ext-mq-cmd-qdel-opt">-f</option>: cancella il file della patch.</para>
+	</listitem>
+      </itemizedlist>
+
+    </sect2>
+    <sect2>
+      <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&rsquo;ultima patch applicata. &Egrave; equivalente al comando <command role="hg-cmd">hg diff -r-2:-1</command>.</para>
+
+    </sect2>
+    <sect2>
+      <title><command role="hg-ext-mq">qfinish</command>&emdash;sposta le patch applicate nella cronologia del repository</title>
+
+      <para id="x_72d">Il comando <command>hg qfinish</command> converte le patch applicate specificate in modifiche permanenti, spostandole fuori dal controllo di MQ in modo che siano trattate come normale cronologia del repository.</para>
+    </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&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&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&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>
+	<listitem><para id="x_5f4"><option role="hg-ext-mq-cmd-qfold-opt">-e</option>: modifica il messaggio di commit e la descrizione di patch per la nuova patch combinata.</para>
+	</listitem>
+	<listitem><para id="x_5f5"><option role="hg-ext-mq-cmd-qfold-opt">-l</option>: usa il testo contenuto nel file dato come nuovo messaggio di commit e descrizione di patch per la patch combinata.</para>
+	</listitem>
+	<listitem><para id="x_5f6"><option role="hg-ext-mq-cmd-qfold-opt">-m</option>: usa il testo dato come nuovo messaggio di commit e descrizione di patch per la patch combinata.</para>
+	</listitem>
+      </itemizedlist>
+
+    </sect2>
+    <sect2>
+      <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&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&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>
+    <sect2>
+      <title><command role="hg-ext-mq">qinit</command>&emdash;prepara un repository per lavorare con MQ</title>
+
+      <para id="x_5fa">Il comando <command role="hg-ext-mq">qinit</command> prepara un repository per lavorare con MQ. Crea una directory chiamata <filename role="special" class="directory">.hg/patches</filename>.</para>
+
+      <para id="x_5fb">Opzioni:</para>
+      <itemizedlist>
+	<listitem><para id="x_5fc"><option role="hg-ext-mq-cmd-qinit-opt">-c</option>: crea <filename role="special" class="directory">.hg/patches</filename> sotto forma di repository. Crea anche un file <filename role="special">.hgignore</filename> che ignorerà il file <filename role="special">status</filename>.</para>
+	</listitem>
+      </itemizedlist>
+
+      <para id="x_5fd">Quando la directory <filename role="special" class="directory">.hg/patches</filename> è un repository, i comandi <command role="hg-ext-mq">qimport</command> e <command role="hg-ext-mq">qnew</command> useranno automaticamente <command role="hg-cmd">hg add</command> per aggiungere nuove patch.</para>
+
+    </sect2>
+    <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&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&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&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&rsquo;inizio del file di patch, prima dei dati di patch.</para>
+	</listitem>
+      </itemizedlist>
+
+    </sect2>
+    <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&rsquo;ultima patch applicata se invocate <command role="hg-ext-mq">qpush</command>.</para>
+
+    </sect2>
+    <sect2>
+      <title><command role="hg-ext-mq">qpop</command>&emdash;estrae le patch dalla pila</title>
+
+      <para id="x_604">Il comando <command role="hg-ext-mq">qpop</command> rimuove patch applicate dalla cima della pila delle patch applicate. Per default, rimuove solo una patch.</para>
+
+      <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&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&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&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&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>
+      </itemizedlist>
+
+      <para id="x_60d">Il comando <command role="hg-ext-mq">qpop</command> rimuove una riga alla fine del file <filename role="special">status</filename> per ogni patch che ha estratto.</para>
+
+    </sect2>
+    <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&rsquo;ultima patch applicata se invocate <command role="hg-ext-mq">qpop</command>.</para>
+
+    </sect2>
+    <sect2 id="sec:mqref:cmd:qpush">
+      <title><command role="hg-ext-mq">qpush</command>&emdash;inserisce le patch in cima alla pila</title>
+
+      <para id="x_60f">Il comando <command role="hg-ext-mq">qpush</command> aggiunge le patch in cima alla pila delle patch applicate. Per default, aggiunge solo una patch.</para>
+
+      <para id="x_610">Questo comando crea un nuovo changeset per rappresentare ogni patch applicata e aggiorna la directory di lavoro per applicare gli effetti delle patch.</para>
+
+      <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&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&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&rsquo;intestazione di patch Mercurial, i dati nell&rsquo;intestazione di patch sostituiscono quelli predefiniti.</para>
+
+      <para id="x_616">Opzioni:</para>
+      <itemizedlist>
+	<listitem><para id="x_617"><option role="hg-ext-mq-cmd-qpush-opt">-a</option>: inserisce tutte le patch non applicate contenute nel file <filename role="special">series</filename> fino a quando non ne rimane nessuna da inserire.</para>
+	</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&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&rsquo;unione durante l&rsquo;inserimento.</para>
+	</listitem>
+      </itemizedlist>
+
+      <para id="x_61b">Il comando <command role="hg-ext-mq">qpush</command> legge, ma non modifica, il file <filename role="special">series</filename>. Aggiunge una riga alla fine del file <filename role="special">status</filename> per ogni patch inserita.</para>
+
+    </sect2>
+    <sect2>
+      <title><command
+	  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&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><para id="x_61e">I cambiamenti al messaggio di commit, cioè al testo che precede la prima intestazione di diff nel file di patch, vengono riflessi nel nuovo changeset che rappresenta la patch.</para>
+	</listitem>
+	<listitem><para id="x_61f">Le modifiche ai file registrati nella directory di lavoro vengono aggiunte alla patch.</para>
+	</listitem>
+	<listitem><para id="x_620">Per quanto riguarda le modifiche ai file registrati apportate tramite <command role="hg-cmd">hg add</command>, <command role="hg-cmd">hg copy</command>, <command role="hg-cmd">hg remove</command>, o <command role="hg-cmd">hg rename</command>, i file aggiunti e i file destinazione di copie e cambiamenti di nome vengono aggiunti alla patch, mentre i file rimossi e i file sorgente dei cambiamenti di nome vengono rimossi.</para>
+	</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&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&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>
+	<listitem><para id="x_625"><option role="hg-ext-mq-cmd-qrefresh-opt">-l</option>: modifica il messaggio di commit e la descrizione della patch, usando il testo contenuto nel file dato.</para>
+	</listitem>
+      </itemizedlist>
+
+    </sect2>
+    <sect2>
+      <title><command role="hg-ext-mq">qrename</command>&emdash;rinomina una patch</title>
+
+      <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&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&rsquo;intera serie di patch</title>
+
+      <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">qtop</command>&emdash;stampa il nome della patch corrente</title>
+
+      <para id="x_62b">Il comando <command role="hg-ext-mq">qtop</command> stampa il nome della patch attualmente in cima alla pila delle patch applicate.</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&rsquo;ordine in cui le patch verrebbero inserite.</para>
+
+    </sect2>
+    <sect2>
+      <title><command role="hg-cmd">hg strip</command>&emdash;rimuove una revisione e i suoi discendenti</title>
+
+      <para id="x_62d">Il comando <command role="hg-cmd">hg strip</command> rimuove una revisione e tutti i suoi discendenti dal repository. Annulla gli effetti delle revisioni rimosse dal repository e aggiorna la directory di lavoro al primo genitore della revisione rimossa.</para>
+
+      <para id="x_62e">Il comando <command role="hg-cmd">hg strip</command> salva una copia di backup dei changeset rimossi in un bundle, in modo che possano essere riapplicati se sono stati rimossi per errore.</para>
+
+      <para id="x_62f">Opzioni:</para>
+      <itemizedlist>
+	<listitem><para id="x_630"><option role="hg-opt-strip">-b</option>: salva i changeset non correlati che sono mescolati ai changeset eliminati nel bundle di backup.</para>
+	</listitem>
+	<listitem><para id="x_631"><option role="hg-opt-strip">-f</option>: se un ramo ha più teste, rimuove tutte le teste.</para>
+	</listitem>
+	<listitem><para id="x_632"><option role="hg-opt-strip">-n</option>: evita di salvare il bundle di backup.</para>
+	</listitem></itemizedlist>
+
+    </sect2>
+  </sect1>
+  <sect1>
+    <title>Guida di riferimento ai file di MQ</title>
+
+    <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&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&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&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>
+      <title>Il file <filename role="special">status</filename></title>
+
+      <para id="x_637">Il flie <filename role="special">status</filename> contiene i nomi e gli hash di changeset per tutte le patch che MQ ha attualmente applicato. A differenza del file <filename role="special">series</filename>, questo file non è destinato a essere modificato. Non dovreste mettere questo file sotto controllo di revisione, né modificarlo in alcun modo. Viene usato da MQ per mantenere traccia di informazioni strettamente private.</para>
+
+    </sect2>
+  </sect1>
+</appendix>

it/appC-srcinstall.xml

+<appendix id="chap:srcinstall">
+  <?dbhtml filename="installare-mercurial-dai-sorgenti.html"?>
+  <title>Installare Mercurial dai sorgenti</title>
+
+  <sect1 id="sec:srcinstall:unixlike">
+    <title>Sistemi di tipo Unix</title>
+
+    <para id="x_5e0">Se state usando un sistema di tipo Unix che include una versione sufficientemente recente di Python (2.3 o superiore), installare Mercurial dai sorgenti è facile.</para>
+    <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&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>
+	<programlisting>cd mercurial-VERSIONE
+python setup.py install --force --home=$HOME</programlisting>
+      </listitem>
+    </orderedlist>
+    <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&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>
+    <title>Windows</title>
+
+    <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&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

+<appendix id="chap:opl">
+  <?dbhtml filename="open-publication-license.html"?>
+  <title>Open Publication License</title>
+
+  <para id="x_638">Questo volume è stato rilasciato sotto licenza Open Publication License, il cui testo viene qui di seguito riportato integralmente nella versione in lingua inglese non essendo disponibile, al momento della pubblicazione del libro, una traduzione ufficiale italiana con il corrispondente valore legale. Il testo della licenza fa riferimento alla Open Publication License versione 1.0, datata 8 giugno 1999.</para>
+
+  <sect1>
+    <title>Requirements on both unmodified and modified versions</title>
+
+    <para id="x_639">The Open Publication works may be reproduced and distributed in whole or in part, in any medium physical or electronic, provided that the terms of this license are adhered to, and that this license or an incorporation of it by reference (with any options elected by the author(s) and/or publisher) is displayed in the reproduction.</para>
+
+    <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&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 the section called <quote>License options</quote>).</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&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>
+    <title>Copyright</title>
+
+    <para id="x_63f">The copyright to each Open Publication is owned by its author(s) or designee.</para>
+
+  </sect1>
+  <sect1>
+    <title>Scope of license</title>
+
+    <para id="x_640">The following license terms apply to all Open Publication works, unless otherwise explicitly stated in the document.</para>
+
+    <para id="x_641">Mere aggregation of Open Publication works or a portion of an Open Publication work with other works or programs on the same media shall not cause this license to apply to those other works. The aggregate work shall contain a notice specifying the inclusion of the Open Publication material and appropriate copyright notice.</para>
+
+    <para id="x_642"><emphasis role="bold">Severability</emphasis>. If any part of this license is found to be unenforceable in any jurisdiction, the remaining portions of the license remain in force.</para>
+
+    <para id="x_643"><emphasis role="bold">No warranty</emphasis>. Open Publication works are licensed and provided <quote>as is</quote> without warranty of any kind, express or implied, including, but not limited to, the implied warranties of merchantability and fitness for a particular purpose or a warranty of non-infringement.</para>
+
+  </sect1>
+  <sect1>
+    <title>Requirements on modified works</title>
+
+    <para id="x_644">All modified versions of documents covered by this license, including translations, anthologies, compilations and partial documents, must meet the following requirements:</para>
+
+    <orderedlist>
+      <listitem><para id="x_645">The modified version must be labeled as such.</para>
+      </listitem>
+      <listitem><para id="x_646">The person making the modifications must be identified and the modifications dated.</para>
+      </listitem>
+      <listitem><para id="x_647">Acknowledgement of the original author and publisher if applicable must be retained according to normal academic citation practices.</para>
+      </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&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>
+  <sect1>
+    <title>Good-practice recommendations</title>
+
+    <para id="x_64a">In addition to the requirements of this license, it is requested from and strongly recommended of redistributors that:</para>
+
+    <orderedlist>
+      <listitem><para id="x_64b">If you are distributing Open Publication works on hardcopy or CD-ROM, you provide email notification to the authors of your intent to redistribute at least thirty days before your manuscript or media freeze, to give the authors time to provide updated documents. This notification should describe modifications, if any, made to the document.</para>
+      </listitem>
+      <listitem><para id="x_64c">All substantive modifications (including deletions) be either clearly marked up in the document or else described in an attachment to the document.</para>
+      </listitem>
+      <listitem><para id="x_64d">Finally, while it is not mandatory under this license, it is considered good form to offer a free copy of any hardcopy and CD-ROM expression of an Open Publication-licensed work to its author(s).</para>
+      </listitem></orderedlist>
+
+  </sect1>
+  <sect1>
+    <title>License options</title>
+
+    <para id="x_64e">The author(s) and/or publisher of an Open Publication-licensed document may elect certain options by appending language to the reference to or copy of the license. These options are considered part of the license instance and must be included with the license (or its incorporation by reference) in derived works.</para>
+
+    <orderedlist numeration="upperalpha">
+      <listitem><para id="x_64f">To prohibit distribution of substantively modified versions without the explicit permission of the author(s). <quote>Substantive modification</quote> is defined as a change to the semantic content of the document, and excludes mere changes in format or typographical corrections.</para>
+      <para id="x_650">To accomplish this, add the phrase <quote>Distribution of substantively modified versions of this document is prohibited without the explicit permission of the copyright holder.</quote> to the license reference or copy.</para>
+      </listitem>
+      <listitem><para id="x_651">To prohibit any publication of this work or derivative works in whole or in part in standard (paper) book form for commercial purposes is prohibited unless prior permission is obtained from the copyright holder.</para>
+      <para id="x_652">To accomplish this, add the phrase <quote>Distribution of the work or derivative of the work in any standard (paper) book form is prohibited unless prior permission is obtained from the copyright holder.</quote> to the license reference or copy.</para>
+      </listitem>
+    </orderedlist>
+
+  </sect1>
+</appendix>

it/bibliography.xml

+<bibliography id="chap:bib">
+<?dbhtml filename="riferimenti.html"?>
+<title>Riferimenti</title>
+
+<biblioentry id="bib:quilt" xreflabel="Quilt">
+  <authorgroup>
+    <author><firstname>Jean</firstname><surname>Delvare</surname></author>
+    <author><firstname>Andreas</firstname><surname>Gruenbacher</surname></author>
+    <author><firstname>Martin</firstname><surname>Quinson</surname></author>
+  </authorgroup>
+  <title>Patchwork quilt</title>
+  <bibliomisc><uri>http://savannah.nongnu.org/projects/quilt</uri></bibliomisc>
+</biblioentry>
+<biblioentry id="bib:diffstat" xreflabel="Dickey">
+  <author><firstname>Thomas</firstname><surname>Dickey</surname></author>
+  <title><literal>diffstat</literal>&emdash;make a histogram of <literal>diff</literal> output</title>
+  <bibliomisc><uri>http://dickey.his.com/diffstat/diffstat.html</uri></bibliomisc>
+</biblioentry>
+<biblioentry id="bib:mysql" xreflabel="MySQL-Python">
+  <author><firstname>Andy</firstname><surname>Dustman</surname></author>
+  <title>MySQL for Python</title>
+  <bibliomisc><uri>http://sourceforge.net/projects/mysql-python</uri></bibliomisc>
+</biblioentry>
+<biblioentry id="bib:gru05" xreflabel="Gruenbacher2005">
+  <author><firstname>Andreas</firstname><surname>Gruenbacher</surname></author>
+  <title>How to survive with many patches (introduction to quilt)</title>
+  <bibliomisc><uri>http://www.suse.de/~agruen/quilt.pdf</uri></bibliomisc>
+  <date>June 2005</date>
+</biblioentry>
+<biblioentry id="bib:mpatch" xreflabel="Mason">
+  <author><firstname>Chris</firstname><surname>Mason</surname></author>
+  <title><literal>mpatch</literal>&emdash;help solve patch rejects</title>
+  <bibliomisc><uri>http://oss.oracle.com/~mason/mpatch/</uri></bibliomisc>
+</biblioentry>
+<biblioentry id="bib:cp" xreflabel="ConfigParser">
+  <corpauthor>Python.org</corpauthor>
+  <title><literal>ConfigParser</literal>&emdash;configuration file parser</title>
+  <bibliomisc><uri>http://docs.python.org/lib/module-ConfigParser.html</uri></bibliomisc>
+</biblioentry>
+<biblioentry id="bib:gnu" xreflabel="GNU-Standard">
+  <authorgroup>
+    <author><firstname>Richard</firstname><surname>Stallman</surname></author>
+    <corpauthor>GNU Project volunteers</corpauthor>
+  </authorgroup>
+  <title>Gnu coding standards&emdash;change logs</title>
+  <bibliomisc><uri>http://www.gnu.org/prep/standards/html_node/Change-Logs.html</uri></bibliomisc>
+</biblioentry>
+<biblioentry id="bib:patchutils" xreflabel="Waugh">
+  <author><firstname>Tim</firstname><surname>Waugh</surname></author>
+  <title><literal>patchutils</literal>&emdash;programs that operate on patch files</title>
+  <bibliomisc><uri>http://cyberelk.net/tim/patchutils/</uri></bibliomisc>
+</biblioentry>
+
+</bibliography>

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

+<preface id="chap:preface">
+  <?dbhtml filename="prefazione.html"?>
+  <title>Prefazione</title>
+
+  <sect1>
+    <title>Raccontare la tecnologia</title>
+
+    <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&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&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&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&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&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&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>
+
+    <para id="x_738">Vorrei anche ringraziare le tante persone che mi hanno aiutato notando errori e fornendo utili suggerimenti in ogni parte del libro.</para>
+
+    <para id="x_739">Jeremy W. Sherman, Brian Mearns, Vincent Furia, Iwan Luijks, Billy Edwards, Andreas Sliwka, Paweł Sołyga, Eric Hanchrow, Steve Nicolai, Michał Masłowski, Kevin Fitch, Johan Holmberg, Hal Wine, Volker Simonis, Thomas P Jakobsen, Ted Stresen-Reuter, Stephen Rasku, Raphael Das Gupta, Ned Batchelder, Lou Keeble, Li Linxiao, Kao Cardoso Félix, Joseph Wecker, Jon Prescot, Jon Maken, John Yeary, Jason Harris, Geoffrey Zheng, Fredrik Jonson, Ed Davies, David Zumbrunnen, David Mercer, David Cabana, Ben Karel, Alan Franzoni, Yousry Abdallah, Whitney Young, Vinay Sajip, Tom Towle, Tim Ottinger, Thomas Schraitle, Tero Saarni, Ted Mielczarek, Svetoslav Agafonkin, Shaun Rowland, Rocco Rutte, Polo-Francois Poli, Philip Jenvey, Petr Tesałék, Peter R. Annema, Paul Bonser, Olivier Scherler, Olivier Fournier, Nick Parker, Nick Fabry, Nicholas Guarracino, Mike Driscoll, Mike Coleman, Mietek Bák, Michael Maloney, László Nagy, Kent Johnson, Julio Nobrega, Jord Fita, Jonathan March, Jonas Nockert, Jim Tittsler, Jeduan Cornejo Legorreta, Jan Larres, James Murphy, Henri Wiechers, Hagen Möbius, Gábor Farkas, Fabien Engels, Evert Rol, Evan Willms, Eduardo Felipe Castegnaro, Dennis Decker Jensen, Deniz Dogan, David Smith, Daed Lee, Christine Slotty, Charles Merriam, Guillaume Catto, Brian Dorsey, Bob Nystrom, Benoit Boissinot, Avi Rosenschein, Andrew Watts, Andrew Donkin, Alexey Rodriguez, Ahmed Chaudhary.</para>
+  </sect1>
+
+  <sect1>
+    <title>Convenzioni usate in questo libro</title>
+
+    <para id="x_73a">Per il testo di questo libro sono state adottate le seguenti convenzioni tipografiche.</para>
+
+    <variablelist>
+      <varlistentry>
+        <term><emphasis>Corsivo</emphasis></term>
+
+        <listitem>
+          <para id="x_73b">Indica nuovi termini, URL, indirizzi email, nomi di file ed estensioni di file.</para>
+        </listitem>
+      </varlistentry>
+
+      <varlistentry>
+        <term><literal>Spaziatura fissa</literal></term>
+
+        <listitem>
+          <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>
+
+      <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&rsquo;utente.</para>
+        </listitem>
+      </varlistentry>
+
+      <varlistentry>
+        <term><replaceable>Spaziatura fissa in corsivo</replaceable></term>
+
+        <listitem>
+          <para id="x_73e">Mostra testo che dovrebbe essere sostituito da valori forniti dall&rsquo;utente oppure determinati dal contesto.</para>
+        </listitem>
+      </varlistentry>
+    </variablelist>
+
+    <tip>
+      <para id="x_73f">Questa icona indica un consiglio, suggerimento, o nota generale.</para>
+    </tip>
+
+    <caution>
+      <para id="x_740">Questa icona indica un avvertimento.</para>
+    </caution>
+  </sect1>
+
+  <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&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&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&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&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&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&rsquo;editore:</para>
+
+    <simplelist type="vert">
+      <member>O’Reilly Media, Inc.</member>
+
+      <member>1005 Gravenstein Highway North</member>
+
+      <member>Sebastopol, CA 95472</member>
+
+      <member>800-998-9938 (negli Stati Uniti o in Canada)</member>
+
+      <member>707-829-0515 (internazionale o locale)</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&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&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&rsquo;Reilly Network, visitate il nostro sito web all&rsquo;indirizzo:</para>
+
+    <simplelist type="vert">
+      <member><ulink url="http://www.oreilly.com"></ulink></member>
+    </simplelist>
+  </sect1>
+</preface>

it/ch01-intro.xml

+<chapter id="chap:intro">
+  <?dbhtml filename="come-siamo-arrivati-qui.html"?>
+  <title>Come siamo arrivati qui?</title>
+
+  <sect1>
+    <title>Perché il controllo di revisione? Perché Mercurial?</title>
+
+    <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&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&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>
+
+    <sect2>
+      <title>Perché usare il controllo di revisione?</title>
+
+      <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&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&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_77">Un aspetto chiave della praticità del controllo di revisione a queste due dimensioni di sviluppo differenti (<quote>programmatore solitario</quote> e <quote>gruppo gigantesco</quote>) è il confronto tra i suoi <emphasis>benefici</emphasis> e i suoi <emphasis>costi</emphasis>. Uno strumento di controllo di revisione che sia difficile da capire e usare finirà per imporre un costo piuttosto alto.</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&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>
+
+      <para id="x_7b">Nessuno strumento di controllo di revisione può salvare un progetto gestito male, ma la scelta degli strumenti adeguati può fare una notevole differenza nella facilità con cui potete lavorare su un progetto.</para>
+
+    </sect2>
+
+    <sect2>
+      <title>I molti nomi del controllo di revisione</title>
+
+      <para id="x_7c">Il controllo di revisione è un campo talmente vario che vi si fa spesso riferimento attraverso diversi nomi e acronimi. Ecco alcune delle variazioni più comuni che incontrerete:</para>
+      <itemizedlist>
+	<listitem><para id="x_7d">controllo di revisione (RCS);</para></listitem>
+	<listitem><para id="x_7e">gestione della configurazione del software (SCM), o gestione della configurazione;</para></listitem>
+	<listitem><para id="x_7f">gestione del codice sorgente;</para></listitem>
+	<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&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&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&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&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>
+
+  <sect1>
+    <title>Le tendenze nel campo</title>
+
+    <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&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>
+
+  </sect1>
+  <sect1>
+    <title>Alcuni vantaggi del controllo di revisione distribuito</title>
+
+    <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&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&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&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_91">Se siete affascinati da un progetto open source e decidete che vi piacerebbe cominciare a lavorarci sopra, e quel progetto usa uno strumento distribuito di controllo di revisione, potete immediatamente operare su un piano di parità con il gruppo di persone che si considerano il <quote>cuore</quote> di quel progetto. Se il gruppo pubblica il proprio repository, potete immediatamente copiare la cronologia del progetto, cominciare a effettuare modifiche e registrare il vostro lavoro utilizzando gli stessi strumenti allo stesso modo dei membri del gruppo. Al contrario, con uno strumento centralizzato, siete costretti a usare il software in modalità di <quote>sola lettura</quote> a meno che qualcuno non vi conceda il permesso di inserire i vostri cambiamenti sul server centrale. Fino a quel momento non sarete in grado di registrare i cambiamenti, e le vostre modifiche rischieranno di venire rovinate ogni volta che provate ad aggiornare la vista del repository dal vostro client.</para>
+
+      <sect3>
+	<title>Il falso problema dei fork</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&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&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&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&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&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&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>
+  <sect1>
+    <title>Perché scegliere Mercurial?</title>
+
+    <para id="x_9c">Mercurial possiede un insieme di caratteristiche unico che lo rende una scelta particolarmente valida come sistema di controllo di revisione.</para>
+    <itemizedlist>
+      <listitem><para id="x_9d">&Egrave; facile da imparare e usare.</para></listitem>
+      <listitem><para id="x_9e">&Egrave; leggero.</para></listitem>
+      <listitem><para id="x_9f">Scala in maniera eccellente.</para></listitem>
+      <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&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&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&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>
+    <title>Un confronto tra Mercurial e altri strumenti</title>
+
+    <para id="x_a5">Prima di proseguire, vi prego di tenere a mente che questa sezione riflette necessariamente la mia esperienza, i miei interessi e (oserei dire) i miei pregiudizi. Ho usato tutti i sistemi di controllo di revisione qui elencati, in più casi per diversi anni alla volta.</para>
+
+    <sect2>
+      <title>Subversion</title>
+
+      <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&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&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&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&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&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&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&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&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_b4">Mercurial può importare la cronologia di revisione da un repository Git.</para>
+
+
+    </sect2>
+    <sect2>
+      <title>CVS</title>
+
+      <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&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&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>
+    <sect2>
+      <title>Strumenti commerciali</title>
+
+      <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&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&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>
+
+      <para id="x_be">Personalmente trovo che le caratteristiche di Mercurial, come la semplicità, le prestazioni e un buon supporto per le unioni, siano una combinazione irresistibile che mi ha servito bene per diversi anni.</para>
+
+    </sect2>
+  </sect1>
+  <sect1>
+    <title>Passare da un altro strumento a Mercurial</title>
+
+    <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_c1">Subversion</para></listitem>
+      <listitem><para id="x_c2">CVS</para></listitem>
+      <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&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&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 &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&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 &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&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&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 &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&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&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&rsquo;uso, prestazioni elevate e scalabilità verso progetti molto grandi.</para>
+  </sect1>
+</chapter>

it/ch02-tour-basic.xml

+<chapter id="chap:tour-basic">
+  <?dbhtml filename="una-panoramica-di-mercurial-i-concetti-di-base.html"?>
+  <title>Una panoramica di Mercurial: i concetti di base</title>
+
+  <sect1 id="sec:tour:install">
+    <title>Installare Mercurial sul vostro sistema</title>
+
+    <para id="x_1">I pacchetti di installazione precompilati che sono disponibili per tutti i sistemi operativi più popolari vi permettono di cominciare facilmente a usare subito Mercurial sul vostro computer.</para>
+
+    <sect2>
+      <title>Windows</title>
+
+      <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&rsquo;indirizzo <ulink url="http://mercurial.berkwood.com">http://mercurial.berkwood.com</ulink>.</para>
+    </sect2>
+
+    <sect2>
+      <title>Linux</title>
+
+      <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&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>
+	  <programlisting>apt-get install mercurial</programlisting></listitem>
+	<listitem><para id="x_5">Fedora:</para>
+	  <programlisting>yum install mercurial</programlisting></listitem>
+	<listitem><para id="x_715">OpenSUSE:</para>
+	  <programlisting>zypper install mercurial</programlisting></listitem>
+	<listitem><para id="x_6">Gentoo:</para>
+	  <programlisting>emerge mercurial</programlisting></listitem>
+      </itemizedlist>
+
+    </sect2>
+    <sect2>
+      <title>Solaris</title>
+
+      <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>
+
+  <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&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&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&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>