[svnbook commit] r1506 - trunk/src/zh/book

rocksun svnbook-dev at red-bean.com
Tue Jun 28 06:22:06 CDT 2005

Author: rocksun
Date: Tue Jun 28 06:22:05 2005
New Revision: 1506

Finish the ch00.xml, ch01.xml, ch02.xml, 
Add glossary.xml for chinese glossary

Modified: trunk/src/zh/book/book.xml
--- trunk/src/zh/book/book.xml	(original)
+++ trunk/src/zh/book/book.xml	Tue Jun 28 06:22:05 2005
@@ -1,8 +1,6 @@
-<?xml version="1.0"?>
-<!DOCTYPE book SYSTEM "../../tools/dtd/dblite.dtd"
+<?xml version="1.0"?>
+<!DOCTYPE book SYSTEM "dtd/dblite.dtd"
-<!ENTITY % vers   SYSTEM "version.xml">
 <!ENTITY foreword SYSTEM "foreword.xml">
 <!ENTITY ch00     SYSTEM "ch00.xml">
 <!ENTITY ch01     SYSTEM "ch01.xml">
@@ -18,16 +16,18 @@
 <!ENTITY appb     SYSTEM "appb.xml">
 <!ENTITY appc     SYSTEM "appc.xml">
 <!ENTITY appd     SYSTEM "appd.xml">
+<!ENTITY glossary     SYSTEM "glossary.xml">
 <!ENTITY license  SYSTEM "copyright.xml">
 <book id="svn">
-  <title>Version Control with Subversion</title>
+  <title>使用Subversion版本控制</title>
   <!-- Using revnumber would be more appropriate, but our stylesheets -->
   <!-- don't seem to render it. -->
-  <subtitle>For Subversion 1.1</subtitle>
-  <subtitle>(book compiled from &svn.version;)</subtitle>
+  <subtitle>针对 Subversion 1.1</subtitle>
+  <subtitle>(本书编译对应1337修订号)</subtitle>
@@ -56,6 +56,10 @@
+    <editor>
+      <firstname>Rock</firstname>
+      <surname>Sun</surname>
+    </editor>
     <pagenums>350 pages (est.)</pagenums>
@@ -70,11 +74,10 @@
       <holder>C. Michael Pilato</holder>
-    <legalnotice><para>This work is licensed under the Creative
-      Commons Attribution License. To view a copy of this license,
-      visit http://creativecommons.org/licenses/by/2.0/ or send a
-      letter to Creative Commons, 559 Nathan Abbott Way, Stanford,
-      California 94305, USA.</para></legalnotice>
+    <legalnotice><para>本书使用创作公用许可证,可以通过访问
+      http://creativecommons.org/licenses/by/2.0/或者发送邮件到Creative Commons, 
+      559 Nathan Abbott Way, Stanford,
+      California 94305, USA来查看本许可证的内容</para></legalnotice>
@@ -95,6 +98,7 @@
+  &glossary;

Modified: trunk/src/zh/book/ch00.xml
--- trunk/src/zh/book/ch00.xml	(original)
+++ trunk/src/zh/book/ch00.xml	Tue Jun 28 06:22:05 2005
@@ -1,44 +1,18 @@
-<preface id="svn-ch-0">
-  <title>Preface</title>
+<preface id="svn-ch-0">
+  <title>序言</title>
-      <para><quote>If C gives you enough rope to hang yourself, think
-        of Subversion as a sort of rope storage facility.</quote>
+      <para><quote>如果C给你足够的绳子吊死你自己,试着用Subversion作为一种存放绳子的工具。</quote>
         —Brian W. Fitzpatrick</para>
-    <para>In the world of open-source software, the Concurrent
-      Versions System (CVS) has long been the tool of choice for
-      version control.  And rightly so.  CVS itself is free software,
-      and its non-restrictive <foreignphrase>modus
-      operandi</foreignphrase> and support for networked
-      operation—which allow dozens of geographically dispersed
-      programmers to share their work—fits the collaborative
-      nature of the open-source world very well.  CVS and its
-      semi-chaotic development model have become cornerstones of
-      open-source culture.
-    </para>
+    <para>在世界上的开源软件领域,并行版本系统(CVS)一直是版本控制的选择。恰如其分的是,CVS本身是一个自由软件,它的非限制性的<foreignphrase>做法</foreignphrase>和对网络操作的支持—允许大量的不同地域分散的程序员可以共享他们的工作的特性—非常适合开源软件领域合作的精神,CVS和它半混乱状态的开发模型成为了开源文化的基石。</para>
-    <para>But like many tools, CVS is starting to show its age.
-      Subversion is a relatively new version control system designed
-      to be the successor to CVS.  The designers set out to win the
-      hearts of CVS users in two ways: by creating an open-source
-      system with a design (and <quote>look and feel</quote>) similar
-      to CVS, and by attempting to fix most of CVS's noticeable flaws.
-      While the result isn't necessarily the next great evolution in
-      version control design, Subversion <emphasis>is</emphasis> very
-      powerful, very usable, and very flexible.
-    </para>
+    <para>但是,像许多工具一样,CVS开始显露出结束的迹象。Subversion是一个相对新的作为CVS继任者的版本控制系统。设计者通过两个方法来争取现有CVS用户的欢迎: 建立一个开源系统,设计(和<quote>感觉</quote>)与CVS类似,并且修补了许多CVS明显的缺陷。结果就是不需要版本控制系统一个大的革新,Subversion<emphasis>非常</emphasis>的强大,可用而且灵活。</para>
-    <para>This book is written to document the 1.1 series of the
-      Subversion version control system.  We have made every attempt to be
-      thorough in our coverage.  However, Subversion has a thriving
-      and energetic development community, so there are already a
-      number of features and improvements planned for future versions
-      of Subversion that may change some of the commands and specific
-      notes in this book.
+    <para>这本书是为Subversion 1.1 系列撰写的,我们努力尝试覆盖所有的部分,但是Subversion有一个兴盛的充满活力的开发社区,所以已经有许多特性和改进将在未来的版本出现,可能会与目前的这本书中的命令与细节不一致
@@ -49,41 +23,15 @@
   <!-- ================================================================= -->
   <sect1 id="svn-ch-0-sect-1">
-    <title>Audience</title>
+    <title>读者</title>
-    <para>This book is written for computer-literate folk who want to
-      use Subversion to manage their data.  While Subversion runs on a
-      number of different operating systems, its primary user
-      interface is command-line based.  It is that command-line tool
-      (<command>svn</command>) which is discussed and used in this
-      book.  For consistency, the examples in this book assume the
-      reader is using a Unix-like operating system, and is relatively
-      comfortable with Unix and command-line interfaces.</para>
-    <para>That said, the <command>svn</command> program also runs on
-      non-Unix platforms like Microsoft Windows.  With a few minor
-      exceptions, such as the use of backward slashes
-      (<literal>\</literal>) instead of forward slashes
-      (<literal>/</literal>) for path separators, the input to and
-      output from this tool when run on Windows are identical to its
-      Unix counterpart.  However, Windows users may find more success
-      by running the examples inside the Cygwin Unix emulation
-      environment.</para>
-    <para>Most readers are probably programmers or sysadmins who need
-      to track changes to source code.  This is the most common use
-      for Subversion, and therefore it is the scenario underlying all
-      of the book's examples.  But Subversion can be used to manage
-      changes to any sort of information: images, music, databases,
-      documentation, and so on.  To Subversion, all data is just
-      data.</para>
+    <para>这本书是为了那些希望使用Subversion管理他们数据的计算机领域的人士准备的,Subversion可以在多种操作系统上运行,它的主要用户操作界面是命令行方式的,这就是我们将要在书中提到命令行工具(<command>svn</command>)。出于一致性,本书的例子假定用户使用的是类Unix的操作系统,并且熟悉Unix命令行操作。</para>
+    <para>也可以知道,这个<command>svn</command>工具也可以运行在非Unit的平台,像Microsoft Windows,只有一些微小的不同,像用反斜线(<literal>\</literal>)代替(<literal>/</literal>)作为路径分隔符,在Windows和Unix上这个工具的输入输出非常类似,Windows用户甚至会发现这个程序能够在Unix仿真工具Cygwin中成功的运行。</para>
+    <para>大多数读者会是期望跟踪代码变化的程序员或系统管理员,这是Subversion最主要的用途,这个场景的例子将贯穿整书。但是Subversion可以管理各种各样的数据:图像、音乐、数据库、文档等等,对于Subversion,所有的数据都只仅仅是数据而已。</para>
-    <para>While this book is written with the assumption that the
-      reader has never used version control, we've also tried to make
-      it easy for users of CVS to make a painless leap into
-      Subversion.  Special sidebars may discuss CVS from time to time,
-      and a special appendix summarizes most of the differences
-      between CVS and Subversion.</para>
+    <para>这本书假定读者从没有使用过任何版本控制系统,我们也努力使CVS用户能够无痛的跳跃到Subversion中,书中一些特别提供的小工具条也将比较Subversion与CVS的区别,最后的附录将总结它们的大多数区别。</para>
@@ -91,70 +39,41 @@
   <!-- ======================== SECTION 2 ============================== -->
   <!-- ================================================================= -->
   <sect1 id="svn-ch-0-sect-2">
-    <title>How to Read this Book</title>
+    <title>怎样阅读本书</title>
-    <para>This book aims to be useful to people of widely different
-      backgrounds—from people with no previous experience in
-      version control to experienced sysadmins.  Depending on your own
-      background, certain chapters may be more or less important to
-      you.  The following can be considered a <quote>recommended
-      reading list</quote> for various types of readers:</para>
+    <para>这本书的目标读者非常的广泛—从从未使用过版本控制的新手到经验丰富的系统管理员。根据你的基础,特定的章节可能对你更有用,下面的内容可以看作是为各类用户提供的<quote>推荐阅读清单</quote>:</para>
-        <term>Experienced sysadmins</term>
+        <term>资深管理员</term>
-          <para>The assumption here is that you've probably used CVS
-            before, and are dying to get a Subversion server up and
-            running ASAP.  Chapters 5 and 6 will show you how to create
-            your first repository and make it available over the
-            network.  After that's done, chapter 3 and appendix A are
-            the fastest routes to learning the Subversion client while
-            drawing on your CVS experience.</para>
+          <para>假设你以前已经使用过CVS,希望得到一个Subversion服务器并且尽快运行起来,第5、6章将会告诉你怎样建立第一个版本库,并且使之在网络上可用,此后,根据你的CVS使用经验,第3章和附录A告诉你怎样使用subversion客户端。</para>
-        <term>New users</term>
+        <term>新用户</term>
-          <para>Your administrator has probably set up Subversion
-            already, and you need to learn how to use the client.  If
-            you've never used a version control system (like CVS),
-            then chapters 2 and 3 are a vital introduction.  If you're
-            already an old hand at CVS, chapter 3 and appendix A are
-            the best place to start.</para>
+          <para>你的管理员已经为你准备好了Subversion服务,你将学习如何使用客户端。如果你没有使用过版本控制系统(像CVS),那么第2、3章是重要的介绍,如果你是CVS的老手,最好从第3章和附录A开始。</para>
-        <term>Advanced users</term>
+        <term>高级用户</term>
-          <para>Whether you're a user or administrator, eventually
-            your project will grow larger.  You're going to want to
-            learn how to do more advanced things with Subversion, such
-            as how to use branches and perform merges (chapter 4),
-            how to use Subversion's property support, how to configure
-            runtime options (chapter 7), and other things.  Chapters 4
-            and 7 aren't vital at first, but be sure to read them once
-            you're comfortable with the basics.</para>
+          <para>无论你只是个使用者还是管理员,最终你的项目会长大,你想通过Subversion作许多高级的事情,像如何使用分支和执行合并(第4章),怎样使用Subversion的属性支持,怎样配制运行参数(第7章)等等。第4,7章一开始并不重要,但你适应了基本操作之后一定要读一下。</para>
-        <term>Developers</term>
+        <term>开发者</term>
-          <para>Presumably, you're already familiar with Subversion,
-            and now want to either extend it or build new software on
-            top of its many APIs.  Chapter 8 is just for you.</para>
+          <para>大概你已经很熟悉subversion了,你想扩展它并在它的API基础上之上开发新软件,第8章将为你准备。</para>
-    <para>The book ends with reference material—chapter 9 is a
-      reference guide for all Subversion commands, and the appendices
-      cover a number of useful topics.  These are the chapters you're
-      mostly likely to come back to after you've finished the
-      book.</para>
+    <para>这本书以一个参考材料作为结束—第9章包括了所有命令的参考,这个附录包括了许多有用的主题,当你完成了本书的阅读,你会经常去看这个章节。</para>
@@ -162,35 +81,34 @@
   <!-- ======================== SECTION 3 ============================== -->
   <!-- ================================================================= -->
   <sect1 id="svn-ch-0-sect-3">
-    <title>Conventions Used in This Book</title>
+    <title>本书约定</title>
-    <para>This section covers the various conventions used in this
-      book.</para>
+    <para>这一部分包括书中各种约定。</para>
     <!-- ***************************************************************** -->
     <sect2 id="svn-ch-0-sect-3.1">
-      <title>Typographic Conventions</title>
+      <title>排版习惯</title>
-          <term><command>Constant width</command></term>
+          <term><command>等宽</command></term>
-            <para>Used for commands, command output, and switches</para>
+            <para>用在命令,命令输出和转换</para>
-          <term><replaceable>Constant width italic</replaceable></term>
+          <term><replaceable>等宽斜体</replaceable></term>
-            <para>Used for replaceable items in code and text</para>
+            <para>用在代码和文本中可替换的部分</para>
-          <term><filename>Italic</filename></term>
+          <term><filename>斜体</filename></term>
-            <para>Used for file and directory names</para>
+            <para>用在文件和路径名</para>
@@ -200,29 +118,22 @@
     <!-- ***************************************************************** -->
     <sect2 id="svn-ch-0-sect-3.2">
-      <title>Icons</title>
+      <title>图标</title>
-        <para>This icon designates a note relating to the surrounding
-          text.</para>
+        <para>这部分内容需要注意的情况。</para>
-        <para>This icon designates a helpful tip relating to the surrounding
-          text.</para>
+        <para>表明有用的小技巧。</para>
-        <para>This icon designates a warning relating to the surrounding
-          text.</para>
+        <para>一些警告信息</para>
-    <para>Note that the source code examples are just
-      that—examples. While they will compile with the proper
-      compiler incantations, they are intended to illustrate the
-      problem at hand, not necessarily serve as examples of good
-      programming style.</para>
+    <para>注意这些源代码只是—例子,需要通过正确编译咒语进行编译,它们只是为了描述在手边的问题,没有必要注意好的编码样式。</para>
@@ -230,145 +141,107 @@
   <!-- ======================== SECTION 4 ============================== -->
   <!-- ================================================================= -->
   <sect1 id="svn-ch-0-sect-4">
-    <title>Organization of This Book</title>
+    <title>本书组织结构</title>
-    <para>The chapters that follow and their contents are listed
-      here:</para>
+    <para>以下是章节和其中的内容介绍:</para>
-          <term>Chapter 1, <emphasis>Introduction</emphasis></term>
+          <term>第1章,<emphasis>介绍</emphasis></term>
-            <para>Covers the history of Subversion as well as its
-              features, architecture, components, and install
-              methods.  Also includes a quick-start guide.</para>
+            <para>记述了Subversion的历史与特性、架构、组件和安装方法,还包括一个快速入门指南。</para>
-          <term>Chapter 2, <emphasis>Basic Concepts</emphasis></term>
+          <term>第2章,<emphasis>基本概念</emphasis></term>
-            <para>Explains the basics of version control and different
-              versioning models, along with Subversion's repository,
-              working copies, and revisions.</para>
+            <para>解释了版本控制的基础知识,介绍了不同的版本模型,随同讲述了Subversion的版本库,工作拷贝和修订版本的概念。</para>
-          <term>Chapter 3, <emphasis>Guided Tour</emphasis></term>
+          <term>第3章,<emphasis>教程</emphasis></term>
-            <para>Walks you through a day in the life of a Subversion
-              user.  It demonstrates how to use Subversion to obtain,
-              modify, and commit data.</para>
+            <para>带领你作为一个Subversion用户开始工作,示范了怎样使用Subversion获得、修改和提交数据。</para>
-          <term>Chapter 4, <emphasis>Branching and Merging</emphasis></term>
+          <term>第4章,<emphasis>分支和合并</emphasis></term>
-            <para>Discusses branches, merges, and tagging, including
-              best practices for branching and merging, common
-              use cases, how to undo changes, and how to easily swing
-              from one branch to the next.</para>
+            <para>讨论分支、合并与标签,包括一个最佳实践,通常的用例,怎样取消修改,以及怎样从一个分支转到另一个分支。</para>
-          <term>Chapter 5, <emphasis>Repository
-            Administration</emphasis></term>
+          <term>第5章,<emphasis>版本库管理</emphasis></term>
-            <para>Describes the basics of the Subversion repository,
-              how to create, configure, and maintain a repository, and
-              the tools you can use to do all of this.</para>
+            <para>讲述Subversion版本库的基本概念,怎样建立、配置和维护版本库,以及你可以使用的工具。</para>
-          <term>Chapter 6, <emphasis>Server Configuration</emphasis></term>
+          <term>第6章,<emphasis>服务器配置</emphasis></term>
-            <para>Explains how to configure your Subversion server and
-              the three ways to access your repository:
-              <literal>HTTP</literal>, the <literal>svn</literal>
-              protocol, and local access.  It also covers the details
-              of authentication, authorization and anonymous
-              access.</para>
+            <para>解释了怎样配置Subversion服务器,以及三种访问版本库的方式,<literal>HTTP</literal>、<literal>svn</literal>协议和本地访问。这里也介绍了认证的细节,以及授权与匿名访问方式。</para>
-          <term>Chapter 7, <emphasis>Advanced Topics</emphasis></term>
+          <term>第7章,<emphasis>高级主题</emphasis></term>
-            <para>Explores the Subversion client configuration files,
-              file and directory properties, how to
-              <literal>ignore</literal> files in your working copy,
-              how to include external trees in your working copy, and
-              lastly, how to handle vendor branches.</para>
+            <para>研究Subversion客户配置文件,文件和目录属性,怎样<literal>忽略</literal>工作拷贝中的文件,怎样引入外部版本树到工作拷贝,最后介绍了如何掌握卖主分支。</para>
-          <term>Chapter 8, <emphasis>Developer Information</emphasis></term>
+          <term>第8章,<emphasis>开发者信息</emphasis></term>
-            <para>Describes the internals of Subversion, the
-              Subversion filesystem, and the working copy
-              administrative areas from a programmer's point of view.
-              Demonstrates how to use the public APIs to write a
-              program that uses Subversion, and most importantly, how
-              to contribute to the development of Subversion.</para>
+            <para>
+            介绍了Subversion的核心,Subversion文件系统,以及从程序员的角度如何看待工作拷贝的管理区域,介绍了如何使用公共APIs写程序使用Subversion,最重要的是,怎样投身到Subversion的开发当中去。
+           </para>
-          <term>Chapter 9, <emphasis>Subversion Complete
-            Reference</emphasis></term>
+          <term>第9章,<emphasis>Subversion完全手册</emphasis></term>
-            <para>Explains in great detail every subcommand of
-              <command>svn</command>, <command>svnadmin</command>, and
-              <command>svnlook</command> with plenty of examples for
-              the whole family!</para>
+            <para>深入研究研究所有的命令,包括
+              <command>svn</command>、<command>svnadmin</command>、和<command>svnlook</command>以及大量的相关实例</para>
-          <term>Appendix A, <emphasis>Subversion for CVS
-            Users</emphasis></term>
+          <term>附录A,<emphasis>为CVS用户准备的Subversion</emphasis></term>
-            <para>Covers the similarities and differences between
-              Subversion and CVS, with numerous suggestions on how to
-              break all the bad habits you picked up from years of
-              using CVS.  Included are descriptions of Subversion
-              revision numbers, versioned directories, offline
-              operations, <command>update</command>
-              vs. <command>status</command>, branches, tags, metadata,
-              conflict resolution, and authentication.</para>
+            <para>
+            比较Subversion与CVS的异同点,消除多年使用CVS养出的坏习惯的建议,包括subversion版本号、标记版本的目录、离线操作、<command>update</command>与<command>status</command>、分支、标签、元数据、冲突和认证。
+           </para>
-          <term>Appendix B, <emphasis>Troubleshooting</emphasis></term>
+          <term>附录B,<emphasis>问题</emphasis></term>
-            <para>Addresses common problems and difficulties using and
-              building Subversion.</para>
+            <para>叙述常见的问题,以及使用和编译Subversion的难点。</para>
-          <term>Appendix C, <emphasis>WebDAV and
-            Autoversioning</emphasis></term>
+          <term>附录C,<emphasis>WebDAV与自动版本化</emphasis></term>
-            <para>Describes the details of WebDAV and DeltaV, and how
-              you can configure your Subversion repository to be
-              mounted read/write as a DAV share.</para>
+            <para>
+            描述了WebDAV与DeltaV的细节,和怎样将你的Subversion版本库作为可读/写的DAV共享装载。</para>
-          <term>Appendix D, <emphasis>Third Party Tools</emphasis></term>
+          <term>附录D,<emphasis>第三方工具</emphasis></term>
-            <para>Discusses tools that support or use Subversion,
-              including alternative client programs, repository
-              browser tools, and so on.</para>
+            <para>
+            讨论一些支持和使用Subversion的工具,包括可选的客户端工具,版本库浏览工具等等。</para>
@@ -376,6 +249,7 @@
   <!-- ================================================================= -->
   <!-- ======================== SECTION 4b ============================= -->
   <!-- ================================================================= -->
@@ -532,38 +406,26 @@
   <!-- ======================== SECTION 5 ============================== -->
   <!-- ================================================================= -->
   <sect1 id="svn-ch-0-sect-5">
-    <title>This Book is Free</title>
+    <title>这本书是免费的</title>
-    <para>This book started out as bits of documentation written by
-      Subversion project developers, which were then coalesced into a
-      single work and rewritten.  As such, it has always been under a
-      free license.  (See <xref linkend="svn-copyright"/>.)  In fact,
-      the book was written in the public eye, as a part of Subversion.
-      This means two things:</para>
+    <para>
+    这本书是作为Subversion项目的文档,由开发者开始撰写的,后来成为一个独立工作并进行了重写,因此,它一直有一个免费许可证(见<xref linkend="svn-copyright"/>。)实际上,这本书是在公众关注中写出来的,作为Subversion的一部分,它有两种含义:</para>
-        <para>You will always find the latest version of this book in
-          the book's own Subversion repository.</para>
+        <para>你一直可以在Subversion的版本库里找到本书的最新版本。</para>
-        <para>You can distribute and make changes to this book however
-          you wish—it's under a free license.  Of course,
-          rather than distribute your own private version of this
-          book, we'd much rather you send feedback and patches to the
-          Subversion developer community.  See <xref
-          linkend="svn-ch-8-sect-6"/> to learn about joining this
-          community.</para>
+        <para>
+        对于这本书,你可以任意分发或者修改—它是免费许可证,当然,相对于发布你的私有版本,你最好向Subversion开发社区提供反馈。为了能够参与到社区,见<xref linkend="svn-ch-8-sect-6"/>来学习如何加入到社区。</para>
-    <para>You can send publishing comments and questions to O'Reilly
-      here: ###insert boilerplate.</para>
+    <para>你可以向O'Reilly发布评论和问题:###insert boilerplate.</para>
-    <para>A relatively recent online version of this book can be found
-      at <systemitem
-      class="url">http://svnbook.red-bean.com</systemitem>.</para>
+    <para>一个相对新的在线版本可以在<systemitem
+      class="url">http://svnbook.red-bean.com</systemitem>找到。</para>
@@ -571,25 +433,17 @@
   <!-- ======================== SECTION 6 ============================== -->
   <!-- ================================================================= -->
   <sect1 id="svn-ch-0-sect-6">
-    <title>Acknowledgments</title>
+    <title>致谢</title>
-    <para>This book would not be possible (nor very useful) if
-      Subversion did not exist.  For that, the authors would like to
-      thank Brian Behlendorf and CollabNet for the vision to fund such
-      a risky and ambitious new Open Source project; Jim Blandy for
-      the original Subversion name and design—we love you, Jim;
-      Karl Fogel for being such a good friend and a great community
-      leader, in that order.<footnote><para>Oh, and thanks, Karl, for
-      being too overworked to write this book yourself.</para>
+    <para>
+    没有Subversion就没有可能(或者有用)有这本书,所以作者很乐意去感谢Brian Behlendorf和CollabNet有眼光,开始这样一个冒险和野心勃勃的开源项目;Jim Blandy给Subversion这个名字和最初的设计—我们爱你。还有Karl Fogel,伟大社区领导和好朋友。
-    <para>Thanks to O'Reilly and our editors, Linda Mui and Tatiana
-      Diaz for their patience and support.</para>
+    <para>感谢O'Reilly和我们的编辑Linda Mui和Tatiana对我们的耐心的支持。</para>
-    <para>Finally, we thank the countless people who contributed to
-      this book with informal reviews, suggestions, and fixes: While
-      this is undoubtedly not a complete list, this book would be
-      incomplete and incorrect without the help of: Jani Averbach,
+    <para>
+最后,我们要感谢数不清的曾经为社区作出贡献的人们,他们提供了非正式的审计、建议和修正:这一定不是一个最终的完整列表,离开了这些人的帮助,这本书不会这样完整和正确:Jani Averbach,
       Ryan Barrett, Francois Beausoleil, Jennifer Bevan, Matt Blais,
       Zack Brown, Martin Buchholz, Brane Cibej, John R. Daily, Peter
       Davis, Olivier Davy, Robert P. J. Day, Mo DeJong, Brian Denny,
@@ -607,78 +461,47 @@
       Larry Shatzer, Russell Steicke, Sander Striker, Erik Sjoelund,
       Johan Sundstroem, John Szakmeister, Mason Thomas, Eric
       Wadsworth, Colin Watson, Alex Waugh, Chad Whitacre, Josef Wolf,
-      Blair Zajac, and the entire Subversion community.</para>
+      Blair Zajac, 以及整个Subversion社区。</para>
     <!-- ***************************************************************** -->
     <sect2 id="svn-ch-0-sect-6.1">
-      <title>From Ben Collins-Sussman</title>
+      <title>来自Ben Collins-Sussman</title>
-      <para>Thanks to my wife Frances, who, for many months, got to
-        hear, <quote>But honey, I'm still working on the book</quote>,
-        rather than the usual, <quote>But honey, I'm still doing
-        email.</quote>  I don't know where she gets all that patience!
-        She's my perfect counterbalance.</para>
+      <para>感谢我的妻子Frances,在几个月里,一直未见,<quote>但是亲爱的,我还在为这本书工作</quote>,非比寻常,<quote>但是亲爱的,我还在处理邮件</quote>。我不知道她为什么会如此耐心!她是我完美的平衡点。</para>
-      <para>Thanks to my extended family for their sincere
-        encouragement, despite having no actual interest in the
-        subject.  (You know, the ones who say, <quote>Ooh, you're
-        writing a book?</quote>, and then when you tell them it's a
-        computer book, sort of glaze over.)</para>
+      <para>感谢我的家人对我的鼓励,无论是否对我的题目感兴趣。(你知道的,一个人说 <quote>哇,你正在写一本书?</quote>,然后当他知道你是写一本计算机书时,那种惊讶就变得没有那么多了)</para>
-      <para>Thanks to all my close friends, who make me a rich, rich man.
-        Don't look at me that way—you know who you are.</para>
+      <para>感谢我身边让我富有的朋友,不要那样看我—你们知道你们是谁。</para>
     <!-- ***************************************************************** -->
     <sect2 id="svn-ch-0-sect-6.2">
-      <title>From Brian W. Fitzpatrick</title>
+      <title>来自Brian W. Fitzpatrick</title>
+      <para>
+      非常非常感谢我的妻子Marie的理解,支持和最重要的耐心。感谢引导我学会UNIX编程的兄弟Eric,感谢我的母亲和外祖母的支持,对我在圣诞夜里埋头工作的理解。</para>
-      <para>Huge thanks to my wife Marie for being incredibly
-        understanding, supportive, and most of all, patient.  Thank
-        you to my brother Eric who first introduced me to UNIX
-        programming way back when. Thanks to my Mom and Grandmother
-        for all their support, not to mention enduring a Christmas
-        holiday where I came home and promptly buried my head in my
-        laptop to work on the book.</para>
-      <para>To Mike and Ben: It was a pleasure working with you on the
-        book.  Heck, it's a pleasure working with you at work!</para>
-      <para>To everyone in the Subversion community and the Apache
-        Software Foundation, thanks for having me.  Not a day goes by
-        where I don't learn something from at least one of you.
+      <para>Mike和Ben:与你们一起工作非常快乐,Heck,我们在一起工作很愉快!</para>
+      <para>感谢所有在Subversion和Apache软件基金会的人们给我机会与你们在一起,没有一天我不从你们那里学到知识。
-      <para>Lastly, thanks to my Grandfather who always told me that
-        <quote>freedom equals responsibility.</quote> I couldn't agree
-        more.</para>
+      <para>最后,感谢我的祖父,他一直跟我说<quote>自由等于责任</quote>。我深信不疑</para>
     <!-- ***************************************************************** -->
     <sect2 id="svn-ch-0-sect-6.3">
-      <title>From C. Michael Pilato</title>
+      <title>来自C. Michael Pilato</title>
+      <para>
+      特别感谢我的妻子Amy,由于她的耐心照顾,由于她对我熬夜的容忍,由于她用难以想象的优雅方式修订我的每一个章节—你总能先行一步。Gavin,你已经大到可以阅读了,我希望你能为我这样一个爸爸感到骄傲,像我为你骄傲一样。爸爸妈妈(家庭的其余部分),感谢你们恒久不变的支持和鼓励。</para>
-      <para>Special thanks to my wife, Amy, for her love and patient
-        support, for putting up with late nights, and for even
-        reviewing entire sections of this book—you always go the
-        extra mile, and do so with incredible grace.  Gavin, when
-        you're old enough to read, I hope you're as proud of your
-        Daddy as he is of you.  Mom and Dad (and the rest of the
-        family), thanks for your constant support and enthusiasm.</para>
-      <para>Hats off to Shep Kendall, through whom the world of
-        computers was first opened to me; Ben Collins-Sussman, my
-        tour-guide through the open-source world; Karl Fogel—you
-        <emphasis>are</emphasis> my <filename>.emacs</filename>; Greg
-        Stein, for oozing practical programming know-how; Brian
-        Fitzpatrick—for sharing this writing experience with me.
-        To the many folks from whom I am constantly picking up new
-        knowledge—keep dropping it!</para>
+      <para>
+      向你们致敬,Shep Kendall,为我打开了计算机世界的大门;Ben Collins Sussman,我在开源世界的导师;Karl Fogel—你<emphasis>是</emphasis>我的<filename>.emacs</filename>;Greg Stain,让我在困境中知道怎样编程;Brain Fitzpatrick—同我分享他的写作经验。所有我曾经从你们那里获得知识的人—尽管又不断忘记。</para>
-      <para>Finally, to the One who perfectly demonstrates creative
-        excellence—thank you.</para>
+      <para>最后,对所有为我展现完美卓越创造力的人们—感谢。</para>

Modified: trunk/src/zh/book/ch01.xml
--- trunk/src/zh/book/ch01.xml	(original)
+++ trunk/src/zh/book/ch01.xml	Tue Jun 28 06:22:05 2005
@@ -1,20 +1,11 @@
-<chapter id="svn-ch-1">
+<chapter id="svn-ch-1">
-  <title>Introduction</title>
+  <title>介绍</title>
-    <para>Version control is the art of managing changes to
-      information.  It has long been a critical tool for programmers,
-      who typically spend their time making small changes to software
-      and then undoing those changes the next day.  But the usefulness
-      of version control software extends far beyond the bounds of the
-      software development world.  Anywhere you can find people using
-      computers to manage information that changes often, there is
-      room for version control.  And that's where Subversion comes
-      into play.</para>
+    <para>版本控制是管理信息变化的艺术,它很早就成为了程序员重要的工具,程序员经常会花时间做一点小修改然后第二天又把它改回来。但是版本控制的作用不仅在软件开发领域,任何需要管理频繁信息改变的地方都需要它,这就是Subversion发挥的舞台。</para>
-    <para>This chapter contains a high-level introduction to
-      Subversion—what it is; what it does; how to get it.</para>
+    <para>这一章是一个对Subversion高层次的介绍—它是什么,它能做什么,它是怎样做到的。</para>
@@ -24,40 +15,16 @@
   <!-- ================================================================= -->
   <sect1 id="svn-ch-1-sect-1">
-    <title>What is Subversion?</title>
+    <title>Subversion是什么?</title>
-    <para>Subversion is a free/open-source version control system.
-      That is, Subversion manages files and directories over time.  A
-      tree of files is placed into a central
-      <firstterm>repository</firstterm>.  The repository is much like
-      an ordinary file server, except that it remembers every change
-      ever made to your files and directories.  This allows you to
-      recover older versions of your data, or examine the history of
-      how your data changed.  In this regard, many people think of a
-      version control system as a sort of <quote>time
-      machine</quote>.</para>
+    <para>
+    Subversion是一个自由/开源版本控制系统,它管理文件和目录可以超越时间。一组文件存放在中心<firstterm>版本库</firstterm>,这个版本库很像一个普通的文件服务器,只是它可以记录每一次文件和目录的修改,这便使你可以取得数据以前的版本,从而可以检查所作的更改。从这个方面看,许多人把版本控制系统当作一种<quote>时间机器</quote>。</para>
-    <para>Subversion can access its repository across networks, which
-      allows it to be used by people on different computers.  At some
-      level, the ability for various people to modify and manage the
-      same set of data from their respective locations fosters
-      collaboration.  Progress can occur more quickly without a single
-      conduit through which all modifications must occur.  And because
-      the work is versioned, you need not fear that quality is the
-      trade-off for losing that conduit—if some incorrect change
-      is made to the data, just undo that change.</para>
-    <para>Some version control systems are also software configuration
-      management (SCM) systems.  These systems are specifically
-      tailored to manage trees of source code, and have many features
-      that are specific to software development—such as natively
-      understanding programming languages, or supplying tools for
-      building software.  Subversion, however, is not one of these
-      systems.  It is a general system that can be used to manage
-      <emphasis>any</emphasis> collection of files.  For you, those
-      files might be source code—for others, anything from
-      grocery shopping lists to digital video mixdowns and
-      beyond.</para>
+    <para>
+    Subversion可以通过网络访问版本库,从而使用户可以在不同的电脑上使用。一定程度上可以说,允许用户在各自的地方修改同一份数据是促进协作。进展可能非常的迅速,并没有一个所有的改变都会取得效果的通道,由于所有的工作都有历史版本,你不必担心由于失去某个通道而影响质量,如果存在不正确的改变,只要取消改变。</para>
+    <para>
+    一些版本控制系统也是软件配置管理(SCM)系统,这种系统经过特定的精巧设计来管理源代码,有许多关于软件开发的特性—本身理解编程语言、或者提供构建程序的工具。然而,Subversion不是这样一个系统,它是一个通用系统,可以管理<emphasis>任何</emphasis>类型的文件集,对你这可能是源代码—对别人,可能是一个货物清单或者是数字电影。</para>
@@ -66,71 +33,23 @@
   <!-- ================================================================= -->
   <sect1 id="svn-ch-1-sect-2">
-    <title>Subversion's History</title>
+    <title>Subversion的历史</title>
+    <para>
+    早在2000年,CollabNet, Inc. (<systemitem
+      class="url">http://www.collab.net</systemitem>) 开始寻找CVS替代产品的开发人员,CollabNet提供了一个协作软件SourceCast,它的一个组件是版本控制系统。尽管SourceCast在初始时使用CVS作为其版本控制系统,但是CVS的局限性在一开始就很明显,CollabNet知道迟早要找到一个更好的替代品。遗憾的是,CVS成为了开源世界<foreignphrase>事实上的</foreignphrase>标准,因为<emphasis>没有</emphasis>更好的产品,至少是没有可以自由使用的。所以CollabNet决定写一个新的版本控制系统,建立在CVS思想之上的,但是修正其错误和不合理的特性。</para>
+    <para>
+    2000年2月,他们联系<citetitle>Open Source Development with CVS</citetitle>(Coriolis, 1999)的作者Karl Fogel,并且询问他是否希望为这个新项目工作,巧合的是,当时Karl正在与朋友Jim Blandy讨论设计一个新的版本控制系统。在1995年,他们两个曾经开办一个提供CVS支持的公司Cyclic Software,尽管他们最终卖掉了公司,但还是天天使用CVS进行日常工作,在使用CVS时的挫折最终促使他们认真地去考虑如何管理标记版本的数据,而且他们当时不仅仅提出了<quote>Subversion</quote>这个名字,并且做出了Subversion版本库的基础设计。所以当CollabNet提出邀请的时候,Karl马上同意为这个项目工作,同时Jim得到了他的雇主,RedHat软件赞助他到这个项目并提供了一个宽松的时间。CollabNet雇佣了Karl和Ben Collins Sussman,详细的设计从三月开始,在Behlendorf 、CollabNet、Jason Robbins  和 Greg Stein(当时是一个独立开发者,活跃在WebDAV/DeltaV系统规范阶段)的恰当激励的帮助下,Subversion很快吸引了许多活跃的开发者,结果是许多有CVS经验的人们很乐于有机会为这个项目做些事情。</para>
+    <para>
+    最初的设计小组固定在简单的目标上,他们不想在版本控制方法学中开垦处女地,他们只是希望修正CVS,他们决定Subversion匹配CVS的特性,保留相同的开发模型,但不复制CVS明显的缺陷。尽管它不需要成为CVS的继任者,它也应该与CVS保持足够的相似性,使得CVS用户可以轻松的做出转换。</para>
-    <para>In early 2000, CollabNet, Inc. (<systemitem
-      class="url">http://www.collab.net</systemitem>) began seeking
-      developers to write a replacement for CVS.  CollabNet offers a
-      collaboration software suite called SourceCast, of which one
-      component is version control.  Although SourceCast used CVS as
-      its initial version control system, CVS's limitations were
-      obvious from the beginning, and CollabNet knew it would
-      eventually have to find something better.  Unfortunately, CVS
-      had become the <foreignphrase>de facto</foreignphrase> standard
-      in the open source world largely because there
-      <emphasis>wasn't</emphasis> anything better, at least not under
-      a free license.  So CollabNet determined to write a new version
-      control system from scratch, retaining the basic ideas of CVS,
-      but without the bugs and misfeatures.</para>
-    <para>In February 2000, they contacted Karl Fogel, the author of
-      <citetitle>Open Source Development with CVS</citetitle>
-      (Coriolis, 1999), and asked if he'd like to work on this new
-      project.  Coincidentally, at the time Karl was already
-      discussing a design for a new version control system with his
-      friend Jim Blandy.  In 1995, the two had started Cyclic
-      Software, a company providing CVS support contracts, and
-      although they later sold the business, they still used CVS every
-      day at their jobs.  Their frustration with CVS had led Jim to
-      think carefully about better ways to manage versioned data, and
-      he'd already come up with not only the name
-      <quote>Subversion</quote>, but also with the basic design of the
-      Subversion repository.  When CollabNet called, Karl immediately
-      agreed to work on the project, and Jim got his employer, RedHat
-      Software, to essentially donate him to the project for an
-      indefinite period of time.  CollabNet hired Karl and Ben
-      Collins-Sussman, and detailed design work began in May.  With
-      the help of some well-placed prods from Brian Behlendorf and
-      Jason Robbins of CollabNet, and Greg Stein (at the time an
-      independent developer active in the WebDAV/DeltaV specification
-      process), Subversion quickly attracted a community of active
-      developers.  It turned out that many people had had the same
-      frustrating experiences with CVS, and welcomed the chance to
-      finally do something about it.</para>
-    <para>The original design team settled on some simple goals.  They
-      didn't want to break new ground in version control methodology,
-      they just wanted to fix CVS.  They decided that Subversion would
-      match CVS's features, and preserve the same development model,
-      but not duplicate CVS's most obvious flaws.  And although it did
-      not need to be a drop-in replacement for CVS, it should be
-      similar enough that any CVS user could make the switch with
-      little effort.</para>
-    <para>After fourteen months of coding, Subversion became
-      <quote>self-hosting</quote> on August 31, 2001.  That is,
-      Subversion developers stopped using CVS to manage Subversion's
-      own source code, and started using Subversion instead.</para>
-    <para>While CollabNet started the project, and still funds a large
-      chunk of the work (it pays the salaries of a few full-time
-      Subversion developers), Subversion is run like most open-source
-      projects, governed by a loose, transparent set of rules that
-      encourage meritocracy.  CollabNet's copyright license is fully
-      compliant with the Debian Free Software Guidelines.  In other
-      words, anyone is free to download, modify, and redistribute
-      Subversion as he pleases; no permission from CollabNet or anyone
-      else is required.</para>
+    <para>
+    经过14个月的编码,2001年8月31日,Subversion自己能够<quote>成为服务</quote>了,开发者停止使用CVS保存Subversion的代码,而使用Subversion本身。</para>
+    <para>
+    当CollabNet开始这个项目的时候,曾经资助了大量的工作(它为全职的Subversion开发者提供薪水),Subversion像许多开源项目一样,被一些激励知识界精英的宽松透明的规则支配着。CollabNet的版权许可证完全符合Debian的自由软件方针,也就是说,任何人可以自由的下载,修改和重新发布,不需要经过CollabNet或其他人的允许。</para>
@@ -139,120 +58,77 @@
   <!-- ================================================================= -->
   <sect1 id="svn-ch-1-sect-3">
-    <title>Subversion's Features</title>
+    <title>Subversion的特性</title>
-    <para>When discussing the features that Subversion brings to the
-      version control table, it is often helpful to speak of them in
-      terms of how they improve upon CVS's design.  If you're not
-      familiar with CVS, you may not understand all of these features.
-      And if you're not familiar with version control at all, your
-      eyes may glaze over unless you first read <xref
-      linkend="svn-ch-2"/>, in which we provide a gentle introduction
-      to version control in general.</para>
+    <para>
+    当讨论Subversion为版本控制领域带来的特性的时候,通过学习它在CVS基础上作的改进会是比较有效的方法。如果你不熟悉CVS,你会不太明白所有的特性,如果你根本就不熟悉版本控制,你会变得目光呆滞,你最好先读一下<xref
+      linkend="svn-ch-2"/>,它提供了版本控制一个简单的介绍。</para>
-    <para>Subversion provides:</para>
+    <para>Subversion提供:</para>
-        <term>Directory versioning</term>
+        <term>版本化的目录</term>
-          <para>CVS only tracks the history of individual files, but
-            Subversion implements a <quote>virtual</quote> versioned
-            filesystem that tracks changes to whole directory trees
-            over time.  Files <emphasis>and</emphasis> directories are
-            versioned.</para>
+          <para>
+          CVS只记录单个文件的历史,但是Subversion实现了一个可以跟踪目录树更改的<quote>虚拟</quote>版本化文件系统,文件<emphasis>和</emphasis>目录都是有版本的。</para>
-        <term>True version history</term>
+        <term>真实的版本历史</term>
-          <para>Since CVS is limited to file versioning, operations
-            such as copies and renames—which might happen to
-            files, but which are really changes to the contents of
-            some containing directory—aren't supported in CVS.
-            Additionally, in CVS you cannot replace a versioned file
-            with some new thing of the same name without the new item
-            inheriting the history of the old—perhaps completely
-            unrelated—file.  With Subversion, you can add,
-            delete, copy, and rename both files and directories.  And
-            every newly added file begins with a fresh, clean
-            history all its own.</para>
+          <para>
+          因为CVS的版本限制在单个文件上,像拷贝和改名操作—文件经常发生的操作,会改变一个目录的内容—在CVS中并不支持。在CVS里你也不可以用一个完全不同的文件覆盖原来的同名文件而又不继承原来文件的历史。通过Subversion,你可以增加、拷贝和改名文件或是目录,也可以新增加一个具有干净历史的文件。</para>
-        <term>Atomic commits</term>
+        <term>原子提交</term>
-          <para>A collection of modifications either goes into the
-            repository completely, or not at all.  This allows
-            developers to construct and commit changes as logical
-            chunks, and prevents problems that can occur when only a
-            portion of a set of changes is successfully sent to the
-            repository.</para>
+          <para>
+          一系列的改动,要么全部提交到版本库,要么一个也不提交,这样可以让用户构建一个提交请求的逻辑块,防止部分修改提交到版本库。</para>
-        <term>Versioned metadata</term>
+        <term>标记版本的元数据</term>
-          <para>Each file and directory has a set of
-            properties—keys and their values—associated
-            with it.  You can create and store any arbitrary key/value
-            pairs you wish.  Properties are versioned over time, just
-            like file contents.</para>
+          <para>
+          每一个文件或目录都有一套属性—键和它们的值,你可以建立并存储任何键/值对,属性是通过时间标记版本,很像文件内容。</para>
-        <term>Choice of network layers</term>
+        <term>网络层的选择</term>
-          <para>Subversion has an abstracted notion of repository
-            access, making it easy for people to implement new network
-            mechanisms.  Subversion can plug into the Apache HTTP
-            Server as an extension module.  This gives Subversion a
-            big advantage in stability and interoperability, and
-            instant access to existing features provided by that
-            server—authentication, authorization, wire
-            compression, and so on.  A more lightweight, standalone
-            Subversion server process is also available.  This server
-            speaks a custom protocol which can be easily tunneled over
-            SSH.</para>
+          <para>
+          Subversion在访问版本库方面有一个抽象的概念,利于人们去实现新的网络机制,Subversion作为一个扩展模块与Apache结合,这给了Subversion在稳定性和交互性方面很大的好处,可以直接使用服务器的特性—认证、授权和压缩等等。也有一个轻型的,单独运行的Subversion服务,这个服务使用自己的协议可以轻松的用SSH封装。</para>
-        <term>Consistent data handling</term>
+        <term>一致的数据操作</term>
-          <para>Subversion expresses file differences using a binary
-            differencing algorithm, which works identically on both
-            text (human-readable) and binary (human-unreadable) files.
-            Both types of files are stored equally compressed in the
-            repository, and differences are transmitted in both
-            directions across the network.</para>
+          <para>
+          Subversion表示文件是建立在二进制文件差别算法基础上的,对于文本(不可读)和二进制(可读)文件具备一致的操作方式,两种类型的文件都压缩存放在版本库中,区别信息是在网络上双向传递的。</para>
-        <term>Efficient branching and tagging</term>
+        <term>有效率的分支和标签</term>
-          <para>The cost of branching and tagging need not be
-            proportional to the project size.  Subversion creates
-            branches and tags by simply copying the project, using a
-            mechanism similar to a hard-link.  Thus these operations
-            take only a very small, constant amount of time.
+          <para>
+          分支与标签的代价不与工程的大小成比例,Subversion建立分支与标签时只是拷贝整个工程,使用了一种类似于硬链接的机制,因而这类操作通常发生很少数量并且固定的次数。
-        <term>Hackability</term>
+        <term>可修改性</term>
-          <para>Subversion has no historical baggage; it is
-            implemented as a collection of shared C libraries with
-            well-defined APIs.  This makes Subversion extremely
-            maintainable and usable by other applications and
-            languages.</para>
+          <para>
+          Subversion没有历史负担,它由一系列良好的共享C库实现,具有定义良好的API,这使得Subversion非常容易维护,可以轻易的用其他语言操作。</para>
@@ -265,26 +141,17 @@
   <!-- ================================================================= -->
   <sect1 id="svn-ch-1-sect-4">
-    <title>Subversion's Architecture</title>
+    <title>Subversion的架构</title>
-    <para><xref linkend="svn-ch-1-dia-1"/> illustrates what one might
-      call a <quote>mile-high</quote> view of Subversion's
-      design.</para>
+    <para><xref linkend="svn-ch-1-dia-1"/>从高处<quote>鸟瞰</quote>Subersion的设计。</para>
     <figure id="svn-ch-1-dia-1">
-      <title>Subversion's Architecture</title>
+      <title>Subversion的架构</title>
       <graphic fileref="images/ch01dia1.png"/>
-    <para>On one end is a Subversion repository that holds all of your
-      versioned data.  On the other end is your Subversion client
-      program, which manages local reflections of portions of that
-      versioned data (called <quote>working copies</quote>).  Between
-      these extremes are multiple routes through various Repository
-      Access (RA) layers.  Some of these routes go across computer
-      networks and through network servers which then access the
-      repository.  Others bypass the network altogether and access the
-      repository directly.</para>
+    <para>
+    一端是Subversion的版本库保存你所有的已经标记版本的数据,在另一端是你的Subvesion客户端程序,管理着所有标记版本的数据的本地影射(叫做<quote>工作拷贝</quote>),在这两极之间是各种各样的版本库访问(RA)层,一些通过电脑网络使用网络服务器访问版本库,一些直接通过网络访问。</para>
@@ -293,40 +160,18 @@
   <!-- ================================================================= -->
   <sect1 id="svn-ch-1-sect-5">
-    <title>Installing Subversion</title>
+    <title>安装Subversion</title>
+    <para>
+    Subversion建立在一个可移植层上,叫做APR(Apache Portable Runtime library),这意味着Subversion可以在所有Apache服务器可以工作的平台上工作:Windows、Linux、各种BSD、Mac OS X、Netware以及其他。</para>
-    <para>Subversion is built on a portability layer called APR (the
-      Apache Portable Runtime library).  This means Subversion should
-      work on any operating system that the Apache httpd server runs
-      on: Windows, Linux, all flavors of BSD, Mac OS X, Netware, and
-      others.</para>
-    <para>The easiest way to get Subversion is to download a binary
-      package built for your operating system.  Subversion's website
-      (<systemitem
-      class="url">http://subversion.tigris.org</systemitem>) often has
-      these packages available for download, posted by volunteers.
-      The site usually contains graphical installer packages for users
-      of Microsoft operating systems.  If you run a Unix-like
-      operating system, you can use your system's native package
-      distribution system (RPMs, DEBs, the ports tree, etc.) to get
-      Subversion.</para>
-    <para>Alternately, you can build Subversion directly from source
-      code.  From the Subversion website, download the latest
-      source-code release.  After unpacking it, follow the
-      instructions in the <filename>INSTALL</filename> file to build
-      it.  Note that a released source package contains everything you
-      need to build a command-line client capable of talking to a
-      remote repository (in particular, the apr, apr-util, and neon
-      libraries).  But optional portions of Subversion have many other
-      dependencies, such as Berkeley DB and possibly Apache httpd.  If
-      you want to do a complete build, make sure you have all of the
-      packages documented in the <filename>INSTALL</filename> file.
-      If you plan to work on Subversion itself, you can use your
-      client program to grab the latest, bleeding-edge source code.
-      This is documented in <xref
-      linkend="svn-ch-8-sect-6.2"/>.</para>
+    <para>
+    最简单的安装办法就是下对应操作系统的二进制包,Subversion的网站(<systemitem
+      class="url">http://subversion.tigris.org</systemitem>)上通常会有志愿者提供的包可以下载,对于微软操作系统,这些网站通常会有图形化的安装包,对于类Unix系统,你可以使用它们本身的打包系统(PRMs、DEBs、ports tree等等)得到Subversion。</para>
+    <para>
+    你也可以选择从源代码直接编译Subversion,从网站下载最新的源代码,解压缩,根据<filename>INSTALL</filename>文件的指导进行编译。注意,通过这些源代码可以完全编译访问服务器的命令行客户端工具(通常是apr,apr-util和neno库)。但是可选部分有许多依赖,像Berkeley DB和Apache httpd。如果你希望做一个完全的编译,确定你有所有<filename>INSTALL</filename>文件中记述的包。如果你计划通过Subversiong本身工作,你可以使用客户端程序取得最新的,带血的源代码,这部分内容见<xref
+      linkend="svn-ch-8-sect-6.2"/>。</para>
@@ -335,76 +180,63 @@
   <!-- ================================================================= -->
   <sect1 id="svn-ch-1-sect-6">
-    <title>Subversion's Components</title>
+    <title>Subversion的组件</title>
-    <para>Subversion, once installed, has a number of different
-      pieces.  The following is a quick overview of what you get.
-      Don't be alarmed if the brief descriptions leave you scratching
-      your head—there are <emphasis>plenty</emphasis> more pages
-      in this book devoted to alleviating that confusion.</para>
+    <para>
+    Subversion安装之后,分为几个部分,这是一个快速浏览。不要害怕这些简略的描述让你挠头,本书有<emphasis>足够的</emphasis>内容来减少混乱。</para>
-          <para>The command-line client program.</para>
+          <para>命令行客户端。</para>
-          <para>A program for reporting the state (in terms of
-            revisions of the items present) of a working copy.</para>
+          <para>报告工作拷贝状态(当前修订版本的项目)的工具。</para>
-          <para>A tool for inspecting a Subversion repository.</para>
+          <para>检查版本库的工具。</para>
-          <para>A tool for creating, tweaking or repairing a Subversion
-            repository.</para>
+          <para>建立、调整和修补版本库的工具。</para>
-          <para>A program for filtering Subversion repository dump
-            streams.</para>
+          <para>过滤Subversion版本库导出流的工具。</para>
-          <para>A plug-in module for the Apache HTTP Server, used to
-            make your repository available to others over a
-            network.</para>
+          <para>Apache HTTP服务器的一个插件,可以让版本库在网络上可见。</para>
-          <para>A custom standalone server program, runnable as a
-            daemon process or invokable by SSH; another way to make
-            your repository available to others over a network.</para>
+          <para>一种单独运行的服务器,可以作为守护进程由SSH调用,另一种让版本库在网络上可见的方式。</para>
-    <para>Assuming you have Subversion installed correctly, you should
-      be ready to start.  The next two chapters will walk you through
-      the use of <command>svn</command>, Subversion's command-line client 
-      program.</para>
+    <para>假定你已经将Subversion安装正确,你已经准备好开始,下两章将带领你使用<command>svn</command>,Subversion的客户端程序。</para>
@@ -414,36 +246,21 @@
   <!-- ================================================================= -->
   <sect1 id="svn-ch-1-sect-7">
-    <title>A Quick Start</title>
+    <title>快速入门</title>
-    <para>Some people have trouble absorbing a new technology by
-      reading the sort of <quote>top down</quote> approach provided by this
-      book.  This section is a very short introduction to Subversion, and is
-      designed to give <quote>bottom up</quote> learners a fighting chance.
-      If you're one of those folks who prefers to learn by
-      experimentation, the following demonstration will get you up and
-      running.  Along the way, we give links to the relevant chapters
-      of this book.</para>
-    <para>If you're new to the entire concept of version control or to
-      the <quote>copy-modify-merge</quote> model used by both CVS and
-      Subversion, then you should read <xref linkend="svn-ch-2"/>
-      before going any further.</para>
+    <para>
+    许多人为<quote>从头到尾</quote>的方式读一本介绍有趣新技术的书感到发愁,这一小节是一个很短的介绍,给许多<quote>实用</quote>的用户一个实战的机会,如果你是一个希望通过实验进行学习的用户,以下将告诉你怎么做,相对应,我们给出这本书相关的链接。</para>
+    <para>
+    如果版本控制或者Subversion和CVS都用到的<quote>拷贝-修改-合并</quote>模型对于你来说是完全的新概念,在进一步阅读之前,你首先要读<xref linkend="svn-ch-2"/>。</para>
-      <para>The following example assumes that you have
-        <command>svn</command>, the Subversion command-line client,
-        and <command>svnadmin</command>, the administrative tool,
-        ready to go.  It also assumes that your <command>svn</command>
-        client has been compiled against Berkeley DB.  To verify this,
-        run <command>svn --version</command> and make sure the
-        <literal>ra_local</literal> module is available.  Without this
-        module, the client cannot access <literal>file://</literal>
-        URLs.</para>
+      <para>
+      以下的例子假定你有了<command>svn</command>这个客户端程序,也有<command>svnadmin</command>这个管理程序,你的<command>svn</command>也应该在Berkeley DB的基础上进行编译。为了验证这些,运行<command>svn --version</command>,确定ra_local模块存在,如果没有,这个程序不能访问<literal>file://</literal>的URL。</para>
-    <para>Subversion stores all versioned data in a central
-      repository.  To begin, create a new repository:</para>
+    <para>
+    Subversion存储标记版本的数据到一个版本库,作为开始,新建一个版本库:</para>
 $ svnadmin create /path/to/repos
@@ -451,21 +268,10 @@
 conf/  dav/  db/  format  hooks/  locks/  README.txt
-    <para>This command creates a new directory
-      <filename>/path/to/repos</filename> which contains a Subversion
-      repository.  Make sure that this directory lives on a local
-      disk, <emphasis>not</emphasis> a network share.  This new
-      directory mainly contains a collection of Berkeley DB database
-      files.  You won't see your versioned files if you peek inside.
-      For more information about repository creation and maintenance,
-      see <xref linkend="svn-ch-5"/>.</para>
-    <para>Next, create a tree of files and directories to import into
-      the repository.  For reasons that will be clear later on (see
-      <xref linkend="svn-ch-4"/>), your structure should contain three
-      top-level directories named <filename>branches</filename>,
-      <filename>tags</filename>, and
-      <filename>trunk</filename>:</para>
+    <para>
+    这个命令建立了一个新的目录 <filename>/path/to/repos</filename>,包含了一个版本库。确定这个目录在本地磁盘上,<emphasis>不是</emphasis>一个网络共享,这个新的目录保存着一些Berkeley DB的数据库文件,你打开后看不到你的已经版本化的文件。更多的版本库创建和维护信息,见第5章<xref linkend="svn-ch-5"/>。</para>
+    <para>第二步,建立一些将要导入到版本库的文件与目录,为了以后使用更清楚(见<xref linkend="svn-ch-4"/>),你的文件应该包括三个顶级目录,分别是<filename>branches</filename>、<filename>tags</filename>和<filename>trunk</filename>:</para>
@@ -477,9 +283,8 @@
-    <para>Once you have a tree of data ready to go, import the data
-      into the repository with the <command>svn import</command>
-      command (see <xref linkend="svn-ch-3-sect-7.3"/>):</para>
+    <para>
+    一旦你有了树形结构和数据你就可以继续了,使用<command>svn import</command>导入数据到版本库(见<xref linkend="svn-ch-3-sect-7.3"/>部分):</para>
 $ svn import /tmp/project file:///path/to/repos -m "initial import"
@@ -494,15 +299,8 @@
-    <para>Now the repository contains this tree of data.  Note that
-      the original <filename>/tmp/project</filename> directory is
-      unchanged; Subversion is unaware of it.  (In fact, you can even
-      delete that directory if you wish.)  In order to start
-      manipulating repository data, you need to create a new
-      <quote>working copy</quote> of the data, a sort of private
-      workspace.  Ask Subversion to <quote>check out</quote> a working
-      copy of the repository's <filename>trunk</filename>
-      directory:</para>
+    <para>
+    现在版本库已经包含你的目录和数据了,注意原先的<filename>/tmp/project</filename>目录没有任何变化;Subversion不管这个,(事实上,你甚至可以任意删除这个目录)。为了处理 版本库的数据,你需要创建一个新的包含数据的<quote>工作拷贝</quote>,一个私人的工作空间。告诉Subversion来<quote>取出</quote>版本库的<filename>trunk</filename>目录:</para>
 $ svn checkout file:///path/to/repos/trunk project
@@ -513,37 +311,29 @@
 Checked out revision 1.
-    <para>Now you have a personal copy of part of the repository in a
-      new directory named <filename>project</filename>.  You can edit
-      the files in your working copy and then commit those changes
-      back into the repository.</para>
+    <para>
+    你现在在<filename>project</filename>目录里有了一个版本库的个人拷贝,你可以编辑你的工作备份中的文件,并且提交到版本库。</para>
-        <para>Enter your working copy and edit a file's
-          contents.</para>
+        <para>进入到你的工作备份,编辑一个文件的内容</para>
-        <para>Run <command>svn diff</command> to see unified diff
-          output of your changes.</para>
+        <para>运行<command>svn diff</command>来查看你的修改的标准区别输出。</para>
-        <para>Run <command>svn commit</command> to commit the new
-          version of your file to the repository.</para>
+        <para>运行<command>svn commit</command>来提交你的改变到版本库</para>
-        <para>Run <command>svn update</command> to bring your working
-          copy <quote>up-to-date</quote> with the repository.</para>
+        <para>运行<command>svn update</command>将你的工作拷贝与版本库<quote>同步</quote>。</para>
-    <para>For a full tour of all the things you can do with your
-      working copy, read <xref linkend="svn-ch-3"/>.</para>
+    <para>对于你对工作拷贝可做操作的完全教程可以å看<xref linkend="svn-ch-3"/>。</para>
-    <para>At this point, you have the option of making your repository
-      available to others over a network.  See <xref
-      linkend="svn-ch-6"/> to learn about the different sorts of
-      server processes available and how to configure them.</para>
+    <para>
+    目前,你可以选择使你的版本库在网络上可见,可以参考<xref
+      linkend="svn-ch-6"/>,学习使用不同的服务器以及配置。</para>

Modified: trunk/src/zh/book/ch02.xml
--- trunk/src/zh/book/ch02.xml	(original)
+++ trunk/src/zh/book/ch02.xml	Tue Jun 28 06:22:05 2005
@@ -1,318 +1,160 @@
-<chapter id="svn-ch-2">
-  <title>Basic Concepts</title>
+<chapter id="svn-ch-2">
+  <title>基本概念</title>
-    <para>This chapter is a short, casual introduction to Subversion.
-      If you're new to version control, this chapter is definitely for
-      you.  We begin with a discussion of general version control
-      concepts, work our way into the specific ideas behind
-      Subversion, and show some simple examples of Subversion in
-      use.</para>
-    <para>Even though the examples in this chapter show people sharing
-      collections of program source code, keep in mind that Subversion
-      can manage any sort of file collection—it's not limited to
-      helping computer programmers.</para>
+    <para>
+    这一章是对Subversion一个简短随意的介绍,如果你对版本控制很陌生,这一章节完全为你准备的,我们从讨论基本概念开始,深入理解Subversion的思想,然后展示许多简单的实例。</para>
+    <para>
+    尽管我们的例子从程序源代码开始,要记住Subversion可以控制所有类型的文件—它并没有限制在为程序员工作。</para>
   <sect1 id="svn-ch-2-sect-1">
-    <title>The Repository</title>  
+    <title>版本库</title>  
-    <para>Subversion is a centralized system for sharing information.
-      At its core is a repository, which is a central store of data.
-      The repository stores information in the form of a
-      <firstterm>filesystem tree</firstterm>—a typical hierarchy
-      of files and directories.  Any number of
-      <firstterm>clients</firstterm> connect to the repository, and
-      then read or write to these files.  By writing data, a client
-      makes the information available to others; by reading data, the
-      client receives information from others.  <xref
-      linkend="svn-ch-2-dia-1"/> illustrates this.</para>
+    <para>
+    Subversion是一种集中的分享信息的系统,它的核心是版本库,它储存所有的数据,版本库按照<firstterm>文件树</firstterm>形式储存数据—包括文件和目录。任意数量的<firstterm>客户端</firstterm>可以连接到版本库,读写这些文件。通过写,别人可以看到这些信息,通过读数据,可以看到别人的修改。<xref
+      linkend="svn-ch-2-dia-1"/>描述了这种关系:</para>
     <figure id="svn-ch-2-dia-1">
-      <title>A typical client/server system</title>
+      <title>一个典型的客户/服务器 系统</title>
       <graphic fileref="images/ch02dia1.png"/>
-    <para>So why is this interesting?  So far, this sounds like the
-      definition of a typical file server.  And indeed, the repository
-      <emphasis>is</emphasis> a kind of file server, but it's not your
-      usual breed.  What makes the Subversion repository special is
-      that <emphasis>it remembers every change</emphasis> ever written
-      to it: every change to every file, and even changes to the
-      directory tree itself, such as the addition, deletion, and
-      rearrangement of files and directories.</para>
-    <para>When a client reads data from the repository, it normally
-      sees only the latest version of the filesystem tree.  But the
-      client also has the ability to view
-      <emphasis>previous</emphasis> states of the filesystem.  For
-      example, a client can ask historical questions like, <quote>What
-      did this directory contain last Wednesday?</quote> or <quote>Who
-      was the last person to change this file, and what changes did
-      they make?</quote> These are the sorts of questions that are at
-      the heart of any <firstterm>version control system</firstterm>:
-      systems that are designed to record and track changes to data
-      over time.
+    <para>
+    所以为什么这很有趣呢?讲了这么多,让人感觉这是一种普通的文件服务器,但实际上,版本库<emphasis>是</emphasis>另一种文件服务器,不是常见的那一种。最特别的是Subversion<emphasis>纪录每一次的更改</emphasis>,不仅针对文件也包括目录本身,包括增加、删除和重新组织文件和目录。</para>
+    <para>
+    当一个客户从版本库读取数据时,通常只会看到最新的版本,但是客户也可以去看<emphasis>以前</emphasis>任何一个版本。举个例子,一个客户可以发出这样的历史问题<quote>上个星期三的目录是怎样的?</quote>或是<quote>谁最后一个更改了这个文件,更改了什么</quote>,这些是每一种<firstterm>版本控制系统</firstterm>的核心问题:系统是设计用来跟踪每一次改动的。
   <sect1 id="svn-ch-2-sect-2">
-    <title>Versioning Models</title>
+    <title>版本模型</title>
-    <para>The core mission of a version control system is to enable
-      collaborative editing and sharing of data.  But different
-      systems use different strategies to achieve this.</para>
+    <para>
+    版本控制系统的核心任务是提供协作编辑和数据共享,但是不同的系统使用不同的策略来达到目的。</para>
     <sect2 id="svn-ch-2-sect-2.1">
-      <title>The Problem of File-Sharing</title>
+      <title>文件共享的问题</title>
-      <para>All version control systems have to solve the same
-        fundamental problem: how will the system allow users to share
-        information, but prevent them from accidentally stepping on
-        each other's feet?  It's all too easy for users to
-        accidentally overwrite each other's changes in the
-        repository.</para>
-      <para>Consider the scenario shown in <xref
-        linkend="svn-ch-2-dia-2"/>.  Suppose we have two co-workers,
-        Harry and Sally.  They each decide to edit the same repository
-        file at the same time.  If Harry saves his changes to the
-        repository first, then it's possible that (a few moments
-        later) Sally could accidentally overwrite them with her own
-        new version of the file.  While Harry's version of the file
-        won't be lost forever (because the system remembers every
-        change), any changes Harry made <emphasis>won't</emphasis> be
-        present in Sally's newer version of the file, because she
-        never saw Harry's changes to begin with.  Harry's work is
-        still effectively lost—or at least missing from the
-        latest version of the file—and probably by accident.
-        This is definitely a situation we want to avoid!</para>
+      <para>
+      所有的版本控制系统需要解决这样一个基础问题:怎样让系统允许用户共享信息,而不会让他们偶然互相干扰?版本库里意外的覆盖别人的更改非常的容易。</para>
+      <para>
+      考虑<xref
+        linkend="svn-ch-2-dia-2"/>的情景,我们有两个共同工作者,Harry和Sally,他们想同时编辑版本库里的同一个文件,如果首先Harry保存它的修改,过了一会,Sally可能凑巧用自己的版本覆盖了这些文件,Harry的更改不会永远消失(因为系统记录了每次修改),Harry所有的修改<emphasis>不会</emphasis>出现在Sally的文件中,Harry的工作还是丢失了—至少是从最新的版本丢失了—而且是意外的,这是我们要明确避免的情况!</para>
       <figure id="svn-ch-2-dia-2">
-        <title>The problem to avoid</title>
+        <title>要避免的问题</title>
         <graphic fileref="images/ch02dia2.png"/>
     <sect2 id="svn-ch-2-sect-2.2">
-      <title>The Lock-Modify-Unlock Solution</title>
+      <title>锁定-修改-解锁 方案</title>
-      <para>Many version control systems use a
-        <firstterm>lock-modify-unlock</firstterm> model to address
-        this problem.  In such a system, the repository allows only
-        one person to change a file at a time.  First Harry must
-        <quote>lock</quote> the file before he can begin making
-        changes to it.  Locking a file is a lot like borrowing a book
-        from the library; if Harry has locked a file, then Sally
-        cannot make any changes to it.  If she tries to lock the file,
-        the repository will deny the request.  All she can do is read
-        the file, and wait for Harry to finish his changes and release
-        his lock.  After Harry unlocks the file, his turn is over, and
-        now Sally can take her turn by locking and editing.  <xref
-        linkend="svn-ch-2-dia-3"/> demonstrates this simple
-        solution.</para>
+      <para>
+      许多版本控制系统使用<firstterm>锁定-修改-解锁</firstterm>这种机制解决这种问题,在这样的系统里,在同一时间段里版本库只允许一个人改变文件。首先在修改之前,Harry要<quote>锁定</quote>住这个文件,锁定很像是从图书馆借一本书,如果Harry锁住这个文件,Sally不能做任何修改,如果Sally想请求得到一个锁,版本库会拒绝这个请求。她只可以阅读文件,直到Harry结束编辑并且放开这个锁。Harry解锁后,就要换班了,Sally得到自己轮换位置开始锁定并且编辑。<xref
+        linkend="svn-ch-2-dia-3"/>描述了这样的解决方案。</para>
       <figure id="svn-ch-2-dia-3">
-        <title>The lock-modify-unlock solution</title>
+        <title>锁定-修改-解锁 方案</title>
         <graphic fileref="images/ch02dia3.png"/>
-      <para>The problem with the lock-modify-unlock model is that it's
-        a bit restrictive, and often becomes a roadblock for
-        users:</para>
+      <para>锁定-修改-解锁模型有一点问题就是限制太多,经常会成为用户的障碍:</para>
-          <para><emphasis>Locking may cause administrative
-            problems.</emphasis>
-            Sometimes Harry will lock a file and then forget about it.
-            Meanwhile, because Sally is still waiting to edit the file,
-            her hands are tied.  And then Harry goes on vacation.  Now
-            Sally has to get an administrator to release Harry's lock.
-            The situation ends up causing a lot of unnecessary delay
-            and wasted time.</para>
+          <para><emphasis>锁定可能导致管理问题。</emphasis>有时候Harry会锁住文件然后忘了此事,这就是说Sally一直等待解锁来编辑这些文件,她在这里僵住了。然后Harry去旅行了,现在Sally只好去找管理员放开锁,这种情况可以导致不必要的耽搁和时间浪费。</para>
-          <para><emphasis>Locking may cause unnecessary
-            serialization.</emphasis>
-            What if Harry is editing the beginning of a text file,
-            and Sally simply wants to edit the end of the same file?
-            These changes don't overlap at all.  They could easily
-            edit the file simultaneously, and no great harm would
-            come, assuming the changes were properly merged together.
-            There's no need for them to take turns in this
-            situation.</para>
+          <para><emphasis>锁定可能导致不必要的线性化开发。</emphasis>如果Harry编辑一个文件的开始,Sally想编辑同一个文件的结尾,这种修改不会冲突,可以轻松的并行工作而没有太多的坏处,没有必要让他们轮流工作。</para>
-          <para><emphasis>Locking may create a false sense of
-            security.</emphasis>
-            Pretend that Harry locks and edits file A, while
-            Sally simultaneously locks and edits file B.  But suppose
-            that A and B depend on one another, and the changes made
-            to each are semantically incompatible.  Suddenly A and B
-            don't work together anymore. The locking system was
-            powerless to prevent the problem—yet it somehow
-            provided a false sense of security.  It's easy for Harry and
-            Sally to imagine that by locking files, each is beginning a
-            safe, insulated task, and thus not bother
-            discussing their incompatible changes early
-            on.</para>
+          <para><emphasis>锁定可能导致错误的安全状态。</emphasis>假设Harry锁定和编辑一个文件A,同时Sally锁定并编辑文件B,如果A和B互相依赖,这种变化是必须同时作的,这样A和B不能正确的工作了,锁定机制对此办法不多—这提供了一种错误的安全状态。很容易想象Harry和Sally都以为自己锁住了文件,而且从一个安全,孤立的情况开始工作,因而没有尽早发现他们不匹配的修改。</para>
     <sect2 id="svn-ch-2-sect-2.3">
-      <title>The Copy-Modify-Merge Solution</title>
+      <title>拷贝-修改-合并 方案</title>
-      <para>Subversion, CVS, and other version control systems use a
-        <firstterm>copy-modify-merge</firstterm> model as an
-        alternative to locking.  In this model, each user's client
-        contacts the project repository and creates a personal
-        <firstterm>working copy</firstterm>—a local reflection
-        of the repository's files and directories.  Users then work in
-        parallel, modifying their private copies.  Finally, the
-        private copies are merged together into a new, final version.
-        The version control system often assists with the merging, but
-        ultimately a human being is responsible for making it happen
-        correctly.</para>
-      <para>Here's an example.  Say that Harry and Sally each create
-        working copies of the same project, copied from the
-        repository.  They work concurrently, and make changes to the
-        same file A within their copies.  Sally saves her changes to
-        the repository first.  When Harry attempts to save his changes
-        later, the repository informs him that his file A is
-        <firstterm>out-of-date</firstterm>.  In other words, that file
-        A in the repository has somehow changed since he last copied
-        it.  So Harry asks his client to <firstterm>merge</firstterm>
-        any new changes from the repository into his working copy of
-        file A.  Chances are that Sally's changes don't overlap with
-        his own; so once he has both sets of changes integrated, he
-        saves his working copy back to the repository.  <xref
-        linkend="svn-ch-2-dia-4"/> and <xref linkend="svn-ch-2-dia-5"/>
-        show this process.</para>
+      <para>
+      Subversion,CVS和一些版本控制系统使用<firstterm>拷贝-修改-合并</firstterm>模型,在这种模型里,每一个客户联系工程版本库建立一个个人<firstterm>工作拷贝</firstterm>—版本库中文件和目录的本地映射。用户并行的使用修改他们自己的工作拷贝,最终,各个私有的拷贝合并在一起,成为最终的版本,这种系统通常可以辅助合并操作,但是最终要人工去确定正误。</para>
+      <para>
+      这是一个例子,Harry和Sally为同一个工程各自建立了一个工作拷贝,工作是并行的,操作同一个文件A,Sally首先保存修改到版本库,当Harry想去提交修改的时候,版本库提示文件A已经<firstterm>过期</firstterm>,换句话说,A在他上次更新之后已经更改了,所以当他通过客户端请求<firstterm>合并</firstterm>版本库和他的工作拷贝之后,碰巧Sally的修改和他的不冲突,所以一旦他把所有的修改集成到一起,他可以将工作拷贝保存到版本库,<xref
+        linkend="svn-ch-2-dia-4"/>和<xref linkend="svn-ch-2-dia-5"/>展示了这一过程。</para>
       <figure id="svn-ch-2-dia-4">
-        <title>The copy-modify-merge solution</title>
+        <title>拷贝-修改-合并 方案</title>
         <graphic fileref="images/ch02dia4.png"/>
       <figure id="svn-ch-2-dia-5">
-        <title>The copy-modify-merge solution (continued)</title>
+        <title>拷贝-修改-合并 方案(续)</title>
         <graphic fileref="images/ch02dia5.png"/>
-      <para>But what if Sally's changes <emphasis>do</emphasis> overlap
-        with Harry's changes?  What then?  This situation is called a
-        <firstterm>conflict</firstterm>, and it's usually not much of
-        a problem.  When Harry asks his client to merge the latest
-        repository changes into his working copy, his copy of file A
-        is somehow flagged as being in a state of conflict: he'll be
-        able to see both sets of conflicting changes, and manually
-        choose between them.  Note that software can't automatically
-        resolve conflicts; only humans are capable of understanding
-        and making the necessary intelligent choices.  Once Harry has
-        manually resolved the overlapping changes—perhaps after
-        a discussion with Sally—he can safely save the
-        merged file back to the repository.</para>
-      <para>The copy-modify-merge model may sound a bit chaotic, but
-        in practice, it runs extremely smoothly.  Users can work in
-        parallel, never waiting for one another.  When they work on
-        the same files, it turns out that most of their concurrent
-        changes don't overlap at all; conflicts are infrequent.  And
-        the amount of time it takes to resolve conflicts is far less
-        than the time lost by a locking system.</para>
-      <para>In the end, it all comes down to one critical factor: user
-        communication.  When users communicate poorly, both syntactic
-        and semantic conflicts increase.  No system can force users to
-        communicate perfectly, and no system can detect semantic
-        conflicts.  So there's no point in being lulled into a false
-        promise that a locking system will somehow prevent conflicts;
-        in practice, locking seems to inhibit productivity more than
-        anything else.</para>
+      <para>
+      但是如果Sally和Harry的修改<emphasis>交迭</emphasis>了该怎么办,这种情况叫做<firstterm>冲突</firstterm>,这通常不是个大问题,当Harry告诉他的客户端去合并版本库到自己的工作备份,他的文件A已经状态混乱:他可以看到有冲突的修改,通过手工的去选择。需要注意的是软件不能自动的解决冲突,只有人可以明白并且作出智能的选择,一旦Harry手工的解决了冲突—也许需要Sally的讨论—它可以安全的把合并的文件保存到版本库。</para>
+      <para>
+      拷贝-修改-合并模型感觉是有一点混乱,但在实践中,通常运行的很平稳,用户可以并行的工作,不必等待别人,当工作在同一个文件上时,结果是很少会有交迭发生,冲突并不频繁,处理冲突的时间远比等待解锁花费的时间少。</para>
+      <para>
+      最后,要面对一件重要的因素:用户交流。当用户交流贫乏,语法和语义的冲突就会增加,没有系统可以强制用户完美的交流,没有系统可以检测语义上的冲突,所以看不出来锁定系统可以防止冲突,实践中,锁定没做多少事情,只是约束了生产力。</para>
   <!-- How svn implements the philosophy -->
   <sect1 id="svn-ch-2-sect-3">
-    <title>Subversion in Action</title>
+    <title>Sunbversion实战</title>
-    <para>It's time to move from the abstract to the concrete.  In
-      this section, we'll show real examples of Subversion being
-      used.</para>
+    <para>
+    是时候从抽象转到具体了,在本小节,我们会展示一个Subversion真实使用的例子。</para>
     <sect2 id="svn-ch-2-sect-3.1">
-      <title>Working Copies</title>
+      <title>工作拷贝</title>
+      <para>
+      你已经阅读过工作拷贝,现在我们要讲一讲客户端怎样建立和使用它。</para>
-      <para>You've already read about working copies; now we'll
-        demonstrate how the Subversion client creates and uses
-        them.</para>
-      <para>A Subversion working copy is an ordinary directory tree on
-        your local system, containing a collection of files.  You can
-        edit these files however you wish, and if they're source code
-        files, you can compile your program from them in the usual
-        way.  Your working copy is your own private work area:
-        Subversion will never incorporate other people's changes, nor
-        make your own changes available to others, until you
-        explicitly tell it to do so.</para>
-      <para>After you've made some changes to the files in your
-        working copy and verified that they work properly, Subversion
-        provides you with commands to <quote>publish</quote> your
-        changes to the other people working with you on your project
-        (by writing to the repository).  If other people publish their
-        own changes, Subversion provides you with commands to merge
-        those changes into your working directory (by reading from the
-        repository).</para>
-      <para>A working copy also contains some extra files, created and
-        maintained by Subversion, to help it carry out these commands.
-        In particular, each directory in your working copy contains a
-        subdirectory named <filename>.svn</filename>, also known as
-        the working copy <firstterm>administrative
-        directory</firstterm>.  The files in each administrative
-        directory help Subversion recognize which files contain
-        unpublished changes, and which files are out-of-date with
-        respect to others' work.</para>
-      <para>A typical Subversion repository often holds the files (or
-        source code) for several projects; usually, each project is a
-        subdirectory in the repository's filesystem tree.  In this
-        arrangement, a user's working copy will usually correspond to
-        a particular subtree of the repository.</para>
-      <para>For example, suppose you have a repository that contains
-        two software projects, <literal>paint</literal> and
-        <literal>calc</literal>.  Each project lives in its own
-        top-level subdirectory, as shown in <xref
-        linkend="svn-ch-2-dia-6"/>.</para>
+      <para>
+      一个Subversion工作拷贝是你本地机器一个普通的目录,保存着一些文件,你可以任意的编辑文件,而且如果是源文件,你可以像平常一样编译他们,你的工作拷贝是你的私有工作区,在你做了特定操作之前,Subversion不会把你的修改与其他人的组合,也不会把你的修改展示给别人。</para>
+      <para>
+      当你在工作拷贝作了一些修改并且确认工作正常之后,Subversion提供了一个命令可以<quote>发布</quote>你的修改给项目中的协作者(通过写到版本库),如果别人发布了各自的修改,Subversion提供了手段可以把这些修改与你的工作目录进行合并(通过读取版本库)。</para>
+      <para>
+      一个工作拷贝也包括一些由Subversion创建并维护的额外文件,用来协助执行这些命令。通常情况下,你的工作拷贝每一个文件夹有一个以<filename>.svn</filename>为名的文件夹,也被叫做工作拷贝<firstterm>管理目录</firstterm>,这个文件帮助Subversion识别那一个文件做过修改,那一个文件已经过时了。</para>
+      <para>
+      一个典型的Subversion的版本库经常包含许多工程的文件(或者说源代码),通常每一个工程是版本库的子目录,在这种安排下,一个用户的工作拷贝往往对应版本库的的一个子目录。</para>
+      <para>
+      举一个例子,你的repository包含两个软件工程,<literal>paint</literal>和<literal>calc</literal>。每一个项目有它们各自的顶级子目录,见xref
+        linkend="svn-ch-2-dia-6"/>。</para>
       <figure id="svn-ch-2-dia-6">
-        <title>The repository's filesystem</title>
+        <title>版本库的文件系统</title>
         <graphic fileref="images/ch02dia6.png"/>
-      <para>To get a working copy, you must <firstterm>check
-        out</firstterm> some subtree of the repository.  (The term
-        <quote>check out</quote> may sound like it has something to do
-        with locking or reserving resources, but it doesn't; it simply
-        creates a private copy of the project for you.) For example,
-        if you check out <filename>/calc</filename>, you will get a
-        working copy like this:</para>
+      <para>
+      为了得到一个工作拷贝,你必须(<firstterm>check
+        out</firstterm>)版本库的一个子树,(术语<quote>check out</quote>听起来像是锁定或者保存资源,实际上不是,只是简单的得到一个项目的私有拷贝),举个例子,你取出 <filename>/calc</filename>,你可以像这样得到工作拷贝:</para>
 $ svn checkout http://svn.example.com/repos/calc
@@ -325,77 +167,59 @@
 Makefile  integer.c  button.c  .svn/
-      <para>The list of letter A's indicates that Subversion is adding
-        a number of items to your working copy.  You now have a
-        personal copy of the repository's <filename>/calc</filename>
-        directory, with one additional
-        entry—<filename>.svn</filename>—which holds the
-        extra information needed by Subversion, as mentioned
-        earlier.</para>
+      <para>
+      列表中的A表示是Subversion是增加一些条目到工作拷贝,你现在有了一个<filename>/calc</filename>的个人拷贝,有一个附加的目录—<filename>.svn</filename>—保存着前面提及的Subversion需要的额外信息。</para>
       <sidebar id="svn-ch-2-sidebar-1">
-        <title>Repository URLs</title>
+        <title>版本库URL</title>
-        <para>Subversion repositories can be accessed through many
-          different methods—on local disk, or through various
-          network protocols.  A repository location, however, is
-          always a URL.  Table 2-1 describes how different URL
-          schemas map to the available access methods.</para>
+        <para>
+        Subversion可以通过多种方式访问—本地磁盘访问,或各种各样不同的网络协议,但一个版本库地址,一直是URL,表格2.1描述了不同的URL模式对应的访问方法。</para>
         <table id="svn-ch-2-table-1">
-          <title>Repository Access URLs</title>
+          <title>版本库访问URL</title>
           <tgroup cols="2">
-                <entry>Schema</entry>
-                <entry>Access Method</entry>
+                <entry>模式</entry>
+                <entry>访问方法</entry>
-                <entry>direct repository access (on local disk)</entry>
+                <entry>直接版本库访问(本地磁盘)</entry>
-                <entry>access via WebDAV protocol to Subversion-aware
-                  Apache server</entry>
+                <entry>通过配置Subversion的Apache服务器的WebDAV协议</entry>
-                <entry>same as <literal>http://</literal>, but with
-                  SSL encryption.</entry>
+                <entry>与<literal>http://</literal>相似,但是包括SSL加密</entry>
-                <entry>access via custom protocol to an
-                  <literal>svnserve</literal> server</entry>
+                <entry>通过<literal>svnserve</literal>服务自定义的协议</entry>
-                <entry>same as <literal>svn://</literal>, but through
-                  an SSH tunnel.</entry>
+                <entry>与<literal>svn://</literal>相似,但通过SSH封装。</entry>
-        <para>For more information on how Subversion parses URLs, see
-        <xref linkend="svn-ch-7-sect-6"/>.</para>
+        <para>关于Subversion解析URL的更多信息,见<xref linkend="svn-ch-7-sect-6"/>。</para>
-      <para>Suppose you make changes to <filename>button.c</filename>.
-        Since the <filename>.svn</filename> directory remembers the
-        file's modification date and original contents, Subversion can
-        tell that you've changed the file.  However, Subversion does
-        not make your changes public until you explicitly tell it to.
-        The act of publishing your changes is more commonly known as
-        <firstterm>committing</firstterm> (or <firstterm>checking
-        in</firstterm>) changes to the repository.</para>
+      <para>
+      假定你修改了<filename>button.c</filename>,因为<filename>.svn</filename>目录记录着文件的修改日期和原始内容,Subversion可以告诉你已经盖过文件了,然而,Subversion不会将你的改变公开,直到你明确的告诉它这样做。将改变公开的操作被叫做提交(<firstterm>committing</firstterm>,或者是<firstterm>checking
+        in</firstterm>)修改到版本库。</para>
-      <para>To publish your changes to others, you can use
-        Subversion's <command>commit</command> command:</para>
+      <para>
+      发布你的修改给别人,你可以使用Subversion的<command>commit</command>命令:</para>
 $ svn commit button.c
@@ -404,24 +228,14 @@
 Committed revision 57.
-      <para>Now your changes to <filename>button.c</filename> have
-        been committed to the repository; if another user checks out a
-        working copy of <filename>/calc</filename>, they will see
-        your changes in the latest version of the file.</para>
-      <para>Suppose you have a collaborator, Sally, who checked out a
-        working copy of <filename>/calc</filename> at the same time
-        you did.  When you commit your change to
-        <filename>button.c</filename>, Sally's working copy is left
-        unchanged; Subversion only modifies working copies at the
-        user's request.</para>
-      <para>To bring her project up to date, Sally can ask
-        Subversion to <firstterm>update</firstterm> her working copy,
-        by using the Subversion <command>update</command> command.
-        This will incorporate your changes into her working copy, as
-        well as any others that have been committed since she checked
-        it out.</para>
+      <para>
+      这时你对<filename>button.c</filename>的修改已经提交到了版本库,如果其他人取出了<filename>/calc</filename>的一个工作拷贝,他们会看到这个文件最新的版本。</para>
+      <para>
+      假设你有个合作者,Sally,她和你同时取出了<filename>/calc</filename>的一个工作拷贝,你提交了你对<filename>button.c</filename>的修改,Sally的工作拷贝并没有改变,subversion只在用户要求的时候才改变工作拷贝。</para>
+      <para>
+      要使项目最新,Sally可以要求Subversion<firstterm>更新</firstterm>她的工作备份,通过使用<command>update</command>命令,将结合你和所有其他人在她上次更新之后的改变到她的工作拷贝。</para>
 $ pwd
@@ -434,77 +248,41 @@
 U button.c
-      <para>The output from the <command>svn update</command> command
-        indicates that Subversion updated the contents of
-        <filename>button.c</filename>.  Note that Sally didn't need to
-        specify which files to update; Subversion uses the information
-        in the <filename>.svn</filename> directory, and further
-        information in the repository, to decide which files need to
-        be brought up to date.</para>
+      <para>
+      <command>svn update</command>命令的输出表明Subversion更新了<filename>button.c</filename>的内容,注意,Sally不必指定要更新的文件,subversion利用<filename>.svn</filename>以及版本库的进一步信息决定哪些文件需要更新。</para>
     <sect2 id="svn-ch-2-sect-3.2">
-      <title>Revisions</title>
+      <title>修订</title>
-      <para>An <command>svn commit</command> operation can publish
-        changes to any number of files and directories as a single
-        atomic transaction.  In your working copy, you can change
-        files' contents, create, delete, rename and copy files and
-        directories, and then commit the complete set of changes as a
-        unit.</para>
-      <para>In the repository, each commit is treated as an atomic
-        transaction: either all the commit's changes take place, or
-        none of them take place.  Subversion tries to retain this
-        atomicity in the face of program crashes, system crashes,
-        network problems, and other users' actions.</para>
-      <para>Each time the repository accepts a commit, this creates a
-        new state of the filesystem tree, called a
-        <firstterm>revision</firstterm>.  Each revision is assigned a
-        unique natural number, one greater than the number of the
-        previous revision.  The initial revision of a freshly created
-        repository is numbered zero, and consists of nothing but an
-        empty root directory.</para>
-      <para><xref linkend="svn-ch-2-dia-7"/> illustrates a nice way to
-        visualize the repository.  Imagine an array of revision
-        numbers, starting at 0, stretching from left to right.  Each
-        revision number has a filesystem tree hanging below it, and
-        each tree is a <quote>snapshot</quote> of the way the
-        repository looked after a commit.</para>
+      <para>
+      一个<command>svn commit</command>操作可以以原子事务操作发布一组文件,在你的工作拷贝里,你可以改变文件内容、删除、改名和拷贝文件和目录,然后作为一个整体提交。</para>
+      <para>
+       在版本库中,每一次提交被当作一次原子事务操作:要不所有的改变发生,要不都不发生,Subversion努力使保持原子性以面对程序冲突、系统冲突、网络问题和其他用户行为。</para>
+      <para>
+      每当一个版本库接受了提交,文件系统进入了一个新的状态,叫做一次修订(<firstterm>revision</firstterm>),每一个修订号是一个独一无二的自然数,一个比一个大,初始修订号是0,只创建了一个空目录,没有任何内容。</para>
+      <para>
+      <xref linkend="svn-ch-2-dia-7"/>使版本库更加形象,想象有一组修订号,从0开始,从左到右,每一个修订号有一个目录树挂在它下面,每一个树好像是一次提交后的版本库<quote>快照</quote>。</para>
       <figure id="svn-ch-2-dia-7">
-        <title>The repository</title>
+        <title>版本库</title>
         <graphic fileref="images/ch02dia7.png"/>
-        <title>Global Revision Numbers</title>
+        <title>全局修订号</title>
-        <para>Unlike those of many other version control systems,
-          Subversion's revision numbers apply to <emphasis>entire
-          trees</emphasis>, not individual files.  Each revision
-          number selects an entire tree, a particular state of the
-          repository after some committed change.  Another way to
-          think about it is that revision N represents the state of
-          the repository filesystem after the Nth commit.  When a
-          Subversion user talks about <quote>revision 5 of
-          <filename>foo.c</filename></quote>, they really mean
-          <quote><filename>foo.c</filename> as it appears in revision 5.</quote>
-          Notice that in general, revisions N and M of a file do
-          <emphasis>not</emphasis> necessarily differ!  Because CVS
-          uses per-file revisions numbers, CVS users might want to see
-          <xref linkend="svn-ap-a"/> for more details.</para>
+        <para>
+        不像其他版本控制系统,Subversion的修订号是针对整个<emphasis>目录树</emphasis>的,而不是单个文件。每一个修订号选择了一次提交后版本库整个目录树的特定状态,另一种理解是修订号N代表版本库已经经过了N次提交。当Subversion用户讨论<quote><filename>foo.c</filename>的修订号5</quote>时,他们的实际意思是<quote>在修订号5时的<filename>foo.c</filename></quote>。需要注意的是,修订号N和M并<emphasis>不</emphasis>表示一个文件需要不同。因为CVS使用每一个文件一个修订号的策略,CVS用户可能希望察看<xref linkend="svn-ap-a"/>来得到更多细节。</para>
-      <para>It's important to note that working copies do not always
-        correspond to any single revision in the repository; they may
-        contain files from several different revisions.  For example,
-        suppose you check out a working copy from a repository whose
-        most recent revision is 4:</para>
+      <para>
+      需要特别注意的是,工作拷贝并不一定对应版本库中的单个修订版本,他们可能包含多个修订版本的文件。举个例子,你从版本库取出一个工作拷贝,最近的修订号是4:</para>
@@ -512,12 +290,8 @@
-      <para>At the moment, this working directory corresponds exactly
-        to revision 4 in the repository.  However, suppose you make a
-        change to <filename>button.c</filename>, and commit that
-        change.  Assuming no other commits have taken place, your
-        commit will create revision 5 of the repository, and your
-        working copy will now look like this:</para>
+      <para>
+      此刻,工作目录与版本库的修订版本4完全对应,然而,你修改了<filename>button.c</filename>并且提交之后,假设没有别的提交出现,你的提交会在版本库建立修订版本5,你的工作拷贝会是这个样子的:</para>
@@ -525,10 +299,8 @@
-      <para>Suppose that, at this point, Sally commits a change to
-        <filename>integer.c</filename>, creating revision 6.  If you
-        use <command>svn update</command> to bring your working copy
-        up to date, then it will look like this:</para>
+      <para>
+      假设此刻,Sally提交了对<filename>integer.c</filename>的修改,建立修订版本6,如果你使用<command>svn update</command>来更新你的工作拷贝,你会看到:</para>
@@ -536,191 +308,123 @@
-      <para>Sally's change to <filename>integer.c</filename> will
-        appear in your working copy, and your change will still be
-        present in <filename>button.c</filename>.  In this example,
-        the text of <filename>Makefile</filename> is identical in
-        revisions 4, 5, and 6, but Subversion will mark your working
-        copy of <filename>Makefile</filename> with revision 6 to
-        indicate that it is still current.  So, after you do a clean
-        update at the top of your working copy, it will generally
-        correspond to exactly one revision in the repository.</para>
+      <para>
+      Sally对<filename>integer.c</filename>的改变会出现在你的工作拷贝,你对<filename>button.c</filename>的改变还在,在这个例子里,<filename>Makefile</filename>在4、5、6修订版本都是一样的,但是Subversion会把他的<filename>Makefile</filename>的修订号设为6来表明它是最新的,所以你在工作拷贝顶级目录作一次干净的更新,会使得所有内容对应同一个修订版本。</para>
     <sect2 id="svn-ch-2-sect-3.3">
-      <title>How Working Copies Track the Repository</title>
+      <title>工作拷贝怎样追踪版本库</title>
-      <para>For each file in a working directory, Subversion records
-        two essential pieces of information in the
-        <filename>.svn/</filename> administrative area:</para>
+      <para>
+      对于工作拷贝的每一个文件,Subversion在管理区域<filename>.svn/</filename>记录两项关键的信息:</para>
-          <para>what revision your working file is based on (this is
-            called the file's <firstterm>working
-            revision</firstterm>), and</para>
+          <para>
+          工作文件所作为基准的修订版本(叫做文件的<firstterm>工作修订版本</firstterm>)和</para>
-          <para>a timestamp recording when the local copy was last
-            updated by the repository.</para>
+          <para>一个本地拷贝最后更新的时间戳。</para>
-      <para>Given this information, by talking to the repository,
-        Subversion can tell which of the following four states a
-        working file is in:</para>
+      <para>给定这些信息,通过与版本库通讯,Subversion可以告诉我们工作文件是处与如下四种状态的那一种:</para>
-          <term>Unchanged, and current</term> 
+          <term>未修改且是当前的</term> 
-            <para>The file is unchanged in the working directory, and
-              no changes to that file have been committed to the
-              repository since its working revision.  An <command>svn
-              commit</command> of the file will do nothing, and an
-              <command>svn update</command> of the file will do
-              nothing.</para>
+            <para>文件在工作目录里没有修改,从工作版本开始没有修改提交到版本库,<command>svn
+              commit</command>操作不做任何事情,<command>svn update</command>不做任何事情。</para>
-          <term>Locally changed, and current</term>
+          <term>本地已修改且是当前的</term>
-            <para>The file has been changed in the working directory,
-              and no changes to that file have been committed to the
-              repository since its base revision.  There are local
-              changes that have not been committed to the repository,
-              thus an <command>svn commit</command> of the file will
-              succeed in publishing your changes, and an <command>svn
-              update</command> of the file will do nothing.</para>
+            <para>在工作目录已经修改,从基本版本之后没有修改提交到版本库,有本地修改没有提交,因此<command>svn commit</command>会成功的提交,<command>svn update</command>不做任何事情。</para>
-          <term>Unchanged, and out-of-date</term> 
+          <term>未修改且不是当前的了</term> 
-            <para>The file has not been changed in the working
-              directory, but it has been changed in the repository.
-              The file should eventually be updated, to make it
-              current with the public revision.  An <command>svn
-              commit</command> of the file will do nothing, and an
-              <command>svn update</command> of the file will fold the
-              latest changes into your working copy.</para>
+            <para>
+            这个文件在工作目录没有修改,但在版本库中已经修改了,这个文件最终更新到最新版本。<command>svn
+              commit</command>不做任何事情,<command>svn update</command>将会取得最新的版本到工作拷贝。</para>
-          <term>Locally changed, and out-of-date</term>
+          <term>本地已修改且不是最新的</term>
-            <para>The file has been changed both in the working
-              directory, and in the repository.  An <command>svn
-              commit</command> of the file will fail with an
-              <quote>out-of-date</quote> error.  The file should be
-              updated first; an <command>svn update</command> command
-              will attempt to merge the public changes with the local
-              changes.  If Subversion can't complete the merge in a
-              plausible way automatically, it leaves it to the user to
-              resolve the conflict.</para>
+            <para>
+            这个文件在工作目录和版本库都得到修改,一个<command>svn
+              commit</command>将会失败,这个文件必须首先更新,<command>svn update</command>命令会合并公共和本地修改,如果Subversion不可以自动完成,将会让用户解决冲突。</para>
-      <para>This may sound like a lot to keep track of, but the
-        <command>svn status</command> command will show you the state
-        of any item in your working copy.  For more information on
-        that command, see <xref linkend="svn-ch-3-sect-5.3.1" />.</para>
+      <para>
+      这看起来需要记录很多事情,但是<command>svn status</command>命令可以告诉你工作拷贝中文件的状态,关于此命令更多的信息,请看<xref linkend="svn-ch-3-sect-5.3.1" />。</para>
     <sect2 id="svn-ch-2-sect-3.4">
-      <title>The Limitations of Mixed Revisions</title>
+      <title>修订版本混合的限制</title>
-      <para>As a general principle, Subversion tries to be as flexible
-        as possible.  One special kind of flexibility is the ability
-        to have a working copy containing mixed revision
-        numbers.</para>
-      <para>At first, it may not be entirely clear why this sort of
-        flexibility is considered a feature, and not a liability.
-        After completing a commit to the repository, the freshly
-        committed files and directories are at a more recent working
-        revision than the rest of the working copy.  It looks like a
-        bit of a mess.  As demonstrated earlier, the working copy can
-        always be brought to a single working revision by running
-        <command>svn update</command>.  Why would someone
-        <emphasis>deliberately</emphasis> want a mixture of working
-        revisions?</para>
-      <para>Assuming your project is sufficiently complex, you'll
-        discover that it's sometimes nice to forcibly
-        <quote>backdate</quote> portions of your working copy to an
-        earlier revision; you'll learn how to do that in Chapter 3.
-        Perhaps you'd like to test an earlier version of a sub-module,
-        contained in a subdirectory, or perhaps you'd like to examine
-        a number of previous versions of a file in the context of the
-        latest tree.</para>
+      <para>作为通常的原则,Subversion期望尽可能的灵活,一个灵活性的表现就是能够在工作拷贝中混合有不同的修订版本。</para>
+      <para>
+      开始的时候,这种灵活性并没有作为一个特性而看得很清楚,也不是一个任务。完成了提交之后,干净的提交的文件比其他文件有更新的版本,这看起来有些混乱,但是像以前说过的,通过<command>svn update</command>使整个版本可以统一起来, 怎么会有人<emphasis>故意的</emphasis>混合版本呢?</para>
+      <para>
+      假设你的项目非常复杂,有时候需要强制地使工作拷贝的一部分<quote>回到</quote>某一个日期,你可以在第3章学习如何操作,或许你也希望测试某一目录下子模块早期的版本,或许你想看某一文件过去的一系列版本。</para>
-      <para>However you make use of mixed-revisions in your working
-        copy, there are limitations to this flexibility.</para>
+      <para>无论你在工作拷贝中如何利用混合版本,对于这种灵活性是有限制的。</para>
+      <para>
+      首先,如果你的提交删除操作的文件或目录不是完全最新时,你不可以提交,如果有 个新的版本存在于版本库,你的删除操作会被拒绝,这防止你不小心破坏你没有见到的东西。</para>
-      <para>First, you cannot commit the deletion of a file or
-        directory which isn't fully up-to-date.  If a newer version of
-        the item exists in the repository, your attempt to delete will
-        be rejected, to prevent you from accidentally
-        destroying changes you've not yet seen.</para>
-      <para>Second, you cannot commit a metadata change to a directory
-        unless it's fully up-to-date.  You'll learn about attaching
-        <quote>properties</quote> to items in Chapter 6.  A
-        directory's working revision defines a specific set of entries
-        and properties, and thus committing a property change to an
-        out-of-date directory may destroy properties you've not yet
-        seen.</para>
+      <para>
+      第二,如果目录已经不是最新的了,你不能提交一个元数据更改到一个目录。你将会在第6章学习附加<quote>属性</quote>,一个目录的工作版本指定许多条目和属性,因而对一个过期的版本提交属性会破坏一些你没有见到的属性。</para>
   <sect1 id="svn-ch-2-sect-4">
-    <title>Summary</title>
+    <title>总结</title>
-    <para>We've covered a number of fundamental Subversion concepts in
-      this chapter:</para>
+    <para>我们在这一章里学习许多Subversion的基本概念:</para>
-        <para>We've introduced the notions of the central repository,
-          the client working copy, and the array of repository
-          revision trees.</para>
+        <para>我们介绍了中央版本库的概念、客户工作拷贝和还有版本修订树。</para>
-        <para>We've seen some simple examples of how two collaborators
-          can use Subversion to publish and receive changes from one
-          another, using the <quote>copy-modify-merge</quote>
-          model.</para>
+        <para>
+        我们介绍了两个协作者如何发布和获得对方的修改,使用<quote>拷贝-修改-合并</quote>模型。</para>
-        <para>We've talked a bit about the way Subversion tracks and
-          manages information in a working copy.</para>
+        <para>我们讨论了一些Subversion在工作拷贝跟踪和管理信息的方式。</para>
-    <para>At this point, you should have a good idea of how Subversion
-      works in the most general sense.  Armed with this knowledge, you
-      should now be ready to jump into the next chapter, which is a
-      detailed tour of Subversion's commands and features.</para>
+    <para>
+    现在,你一定对subversion的工作原理有了很好的认识,有了这些知识的武装,你一定准备好跳到下一章去了,一个关于Subversion命令与特性的详细教程。</para>

Modified: trunk/src/zh/book/foreword.xml
--- trunk/src/zh/book/foreword.xml	(original)
+++ trunk/src/zh/book/foreword.xml	Tue Jun 28 06:22:05 2005
@@ -1,126 +1,42 @@
-<!-- There doesn't seem to be a 'foreword' element similar to the
+<!-- There doesn't seem to be a 'foreword' element similar to the
 'preface' element.  Not sure what to use instead; I guess 'preface' is
 the best solution for now, even though there's also a real preface in
 ch00.xml. -->
 <preface id="svn-foreword">
-  <title>Foreword</title>
-    <para>A bad Frequently Asked Questions (FAQ) sheet is one that is
-      composed not of the questions people actually asked, but of the
-      questions the FAQ's author <emphasis>wished</emphasis> people
-      had asked.  Perhaps you've seen the type before:</para>
+    <para>一个常见问题列表(FAQ),常常并不是由人们实际上的问题组成,而经常是由作者<emphasis>期待的</emphasis>问题组成。或许你曾经见过这种类型的问题:</para>
-      <para>Q: How can I use Glorbosoft XYZ to maximize team
-        productivity?</para>
+      <para>Q:怎样使用Glorbosoft XYZ提高生产率?</para>
-      <para>A: Many of our customers want to know how they can
-        maximize productivity through our patented office groupware
-        innovations.  The answer is simple: first, click on the
-        <quote><literal>File</literal></quote> menu, scroll down to
-        <quote><literal>Increase Productivity</literal></quote>,
-        then…</para>
+      <para>A: 许多客户希望知道怎样通过革新我们特许的办公室群件来提高生产率,回答非常简单:首先,点击<quote><literal>文件</literal></quote> 菜单,鼠标移到<quote><literal>提高生产率</literal></quote>,然后…</para>
-    <para>The problem with such FAQs is that they are not, in a
-      literal sense, FAQs at all.  No one ever called the tech support
-      line and asked, <quote>How can we maximize
-      productivity?</quote>.  Rather, people asked highly specific
-      questions, like, <quote>How can we change the calendaring system
-      to send reminders two days in advance instead of one?</quote>
-      and so on.  But it's a lot easier to make up imaginary
-      Frequently Asked Questions than it is to discover the real ones.
-      Compiling a true FAQ sheet requires a sustained, organized
-      effort: over the lifetime of the software, incoming questions
-      must be tracked, responses monitored, and all gathered into a
-      coherent, searchable whole that reflects the collective
-      experience of users in the wild.  It calls for the patient,
-      observant attitude of a field naturalist.  No grand
-      hypothesizing, no visionary pronouncements here—open eyes
-      and accurate note-taking are what's needed most.</para>
-    <para>What I love about this book is that it grew out of just such
-      a process, and shows it on every page.  It is the direct result
-      of the authors' encounters with users.  It began with Ben
-      Collins-Sussman's observation that people were asking the same
-      basic questions over and over on the Subversion mailing lists:
-      What are the standard workflows to use with Subversion?  Do
-      branches and tags work the same way as in other version control
-      systems?  How can I find out who made a particular change?</para>
-    <para>Frustrated at seeing the same questions day after day, Ben
-      worked intensely over a month in the summer of 2002 to write
-      <citetitle>The Subversion Handbook</citetitle>, a sixty page
-      manual that covered all the basics of using Subversion.  The
-      manual made no pretense of being complete, but it was
-      distributed with Subversion and got users over that initial hump
-      in the learning curve.  When O'Reilly and Associates decided to
-      publish a full-length Subversion book, the path of least
-      resistance was obvious: just expand the Subversion
-      handbook.</para>
-    <para>The three co-authors of the new book were thus presented
-      with an unusual opportunity.  Officially, their task was to
-      write a book top-down, starting from a table of contents and an
-      initial draft.  But they also had access to a steady
-      stream—indeed, an uncontrollable geyser—of bottom-up
-      source material.  Subversion was already in the hands of
-      thousands of early adopters, and those users were giving tons of
-      feedback, not only about Subversion, but about its existing
-      documentation.</para>
-    <para>During the entire time they wrote this book, Ben, Mike, and
-      Brian haunted the Subversion mailing lists and chat rooms
-      incessantly, carefully noting the problems users were having in
-      real-life situations.  Monitoring such feedback is part of their
-      job descriptions at CollabNet anyway, and it gave them a huge
-      advantage when they set out to document Subversion.  The book
-      they produced is grounded firmly in the bedrock of experience,
-      not in the shifting sands of wishful thinking; it combines the
-      best aspects of user manual and FAQ sheet.  This duality might
-      not be noticeable on a first reading.  Taken in order, front to
-      back, the book is simply a straightforward description of a
-      piece of software.  There's the overview, the obligatory guided
-      tour, the chapter on administrative configuration, some advanced
-      topics, and of course a command reference and troubleshooting
-      guide.  Only when you come back to it later, seeking the
-      solution to some specific problem, does its authenticity shine
-      out: the telling details that can only result from encounters
-      with the unexpected, the examples honed from genuine use cases,
-      and most of all the sensitivity to the user's needs and the
-      user's point of view.</para>
-    <para>Of course, no one can promise that this book will answer
-      every question you have about Subversion.  Sometimes, the
-      precision with which it anticipates your questions will seem
-      eerily telepathic; yet occasionally, you will stumble into a
-      hole in the community's knowledge, and come away empty-handed.
-      When this happens, the best thing you can do is email
-      <email>users at subversion.tigris.org</email> and present your
-      problem.  The authors are still there, still watching, and they
-      include not just the three listed on the cover, but many others
-      who contributed corrections and original material.  From the
-      community's point of view, solving your problem is merely a
-      pleasant side effect of a much larger project—namely,
-      slowly adjusting this book, and ultimately Subversion itself, to
-      more closely match the way people actually use it.  They are
-      eager to hear from you not merely because they can help you, but
-      because you can help them.  With Subversion as with all active
-      free software projects, <emphasis>you are not
-      alone</emphasis>.</para>
+    <para>问题是这样的FAQ并不是其字面意义上的FAQ,没有人会这样询问支持者,<quote>怎样提高生产率?</quote>相反,人们经常询问一些更具体的问题,像<quote>怎样修改日程系统提前两天而不是提前一天去提醒被提醒人?</quote>等等。但是通过想象比去发现一个这样的问题列表更容易,编辑一个真实的问题列表需要持续的,有组织的工作,覆盖软件的整个生命周期,提出的问题必须被追踪,要监控反馈,所有问题要收集为一个一致的,可查询的整体,并且能够反映所有用户的经验。这需要耐心,像实地博物学家一样严谨的态度,不应该有浮华的假设,虚幻的断言 — 而需要开放的视野和精确的记录。</para>
-    <para>Let this book be your first companion.</para>
+    <para>之所以会喜欢这本书,是因为这本书非凡的成长过程,这体现在每一页里,这是作者与用户直接交流的结果。这一切的基础是Ben Collins-Sussman's关于subversion常见问题邮件列表的研究:使用subversion通常的流程是怎样的?分支与标签同其它版本控制系统的工作方式是一样的吗?我怎样知道某一处修改是谁做的?</para>
+<para>由于每天看到相同问题的失落,Ben在2002年夏天努力工作了一个月,撰写了一本<citetitle>Subversion手册</citetitle>,一本六十页,涵盖了所有基础使用知识的手册。这本手册没有说明什么时候要结束,伴随着Subversion的版本,帮助用户开始最初的学习。当O'Reilly and Associates决定出版一本完备的Subversion图书的时候,最快捷的方式很明显,就是扩充这本书。</para>
+    <para>三个联合作者因而面临了一个不寻常的机会。从职责上讲,他们的任务是以一些原始内容为基础,从头到尾写一个草稿。但实际上他们正在使用着一些丰富的自下而上的原材料,像一条稳定的河流,也可能是一口不可预料的间歇泉。Subversion被数以千计的用户采用,这些用户提供了大量的反馈,不仅仅针对Subversion,还包括业已存在的文档。</para>
+<para>在写这本书的过程里,Ben, Mike 和 Brian向鬼魂一样一直游荡在Subversion邮件列表和聊天室中,仔细的研究用户实际遇到的问题。监视这些反馈是他们在CollabNet工作的一部分,这给他们开始写这本书时提供了巨大的便利。这本书建立在丰富经验的根基之上,而并不在流沙一样的想象之上;它结合了用户手册和FAQ最好的一面,在第一次阅读时,这种二元性并不明显,按照顺序,从前到后,这本书只是简单的从头到尾的关于软件细节的描述。有一个总的看法,有一个教程,有一章关于管理配置,还有一些高级主题,当然也有一个命令参考和故障指南。只有当你过一段时间之后,返回来找一些特定问题的解决方案时,这种二元的确实性才得以显现:这些生动的细节一定来自不可预料的实际用例的提炼,大多是源于用户的需要和视点。</para>
+    <para>当然,没人可以承诺这本书可以回答所有问题。尽管有时候一些先前别人提的问题的惊人一致让你感觉是心灵感应;你仍有可能在社区的知识库里摔跤,空手而归。如果有这种情况,最好的办法是写明问题发送email到<email>users at subversion.tigris.org</email>,作者还在那里关注着社区,不仅仅封面提到的三位,还包括许多曾经作出修正与提供原始材料这种贡献的人。从社区的视角,帮你解决问题只是逐步的调整这本书,进一步调整Subversion本身以更合理的适合用户使用这样一个大工程的一个有趣的额外效用。他们渴望你的信息,不仅仅可以帮助你,也因为可以帮助他们。与Subversion这样活跃的自由软件项目一起,<emphasis>你并不孤单</emphasis>。</para>
+    <para>让这本书将成为你的第一个伙伴。</para>
-      </author>, Chicago, 14 March, 2004</para>
+      </author>,芝加哥,2004年3月15日</para>

More information about the svnbook-dev mailing list