Source

hgbook-ru / ru / ch01-intro.xml

Full commit
<!-- vim: set filetype=docbkxml shiftwidth=2 autoindent expandtab tw=77 : -->

<chapter id="chap:intro">
  <?dbhtml filename="how-did-we-get-here.html"?>
  <title>Как мы сюда попали?</title>

  <sect1>
    <title>Зачем нужен контроль версий? Почему Mercurial?</title>

    <para id="x_6d">Контроль ревизии представляет собой процесс управления несколькими версиями информации. В своей простейшей форме, это то, что многие люди делают вручную: каждый раз, когда вы изменяете файл, сохраняя его под новым именем, которое содержит номер, каждый из которых выше, чем число предшествующей версии.</para>

    <para id="x_6e">Ручное управление несколькими версиями для одного файла &emdash; задача с возможностью ошибок, хотя программные средства для автоматизации этого процесса давно уже доступны. Первые автоматизированные средства контроля версий были созданы, чтобы помочь одному человеку управлять версиями одного файла. За последние несколько десятилетий, количество инструментов контроля версий значительно увеличилось. Теперь они управляют версиями многих файлов, и помогают нескольким людям работать вместе. Благодаря лучшим современным средствам контроля версий тысячи людей могут работать над общими проектами, содержащими сотни тысяч файлов.</para>

    <para id="x_6f">Распределенные системы контроля версий появились относительно недавно, однако, эта область быстро развивается благодаря тяге людей к исследованию нового.</para>

    <para id="x_70">Я пишу книгу о распределенных системах контроля версий, потому что считаю, что это важная тема, которая заслуживает руководства. Я решил написать о Mercurial, потому что это простой инструмент, чтобы познакомится с этой областью, в то же время &emdash; это реальный инструмент, отработанный в сложных условиях, когда многие другие средства контроля версий ещё не проверены.</para>

    <sect2>
      <title>Зачем использовать систему контроля версий?</title>

      <para id="x_71">Есть ряд причин, по которым вы или ваша команда может использоваться автоматизированную систему контроля версий для вашего проекта.</para>

      <itemizedlist>
	<listitem><para id="x_72">Она будет отслеживать историю и прогресс вашего проекта вместо вас. Для каждого изменения у вас будет запись о том, <emphasis>кто</emphasis> его сделал, <emphasis>почему</emphasis> он это сделал, <emphasis>когда</emphasis> он это сделал и <emphasis>в чем</emphasis>, собственно, заключалось изменение.</para></listitem>
	<listitem><para id="x_73">Когда вы работаете с другими людьми, система контроля версий облегчает вам взаимодействие. Например, когда несколько человек делают потенциально конфликтные изменения одновременно, программа поможет вам определить и разрешить такие конфликты.</para></listitem>
	<listitem><para id="x_74">Она может помочь вам восстановиться после ошибок. Если вы сделаете изменение, которое потом окажется ошибкой, вы сможете вернуться к более ранней версии одного или нескольких файлов. На самом деле, <emphasis>действительно</emphasis> хорошая система контроля версий даже поможет вам легко найти тот момент времени, когда проблема впервые появилась (см. <xref linkend="sec:undo:bisect"/>).</para></listitem>
	<listitem><para id="x_75">Она поможет вам работать одновременно над несколькими версиями проекта и переключаться между ними.</para></listitem>
      </itemizedlist>

      <para id="x_76">Все эти причины одинаково важны (по крайней мере, в теории) независимо от того, работаете ли вы над проектом в одиночку или вместе с сотней других людей.</para>

      <para id="x_77">Ключевой вопрос относительно практичности системы контроля версий в таких разных средах (<quote>хакер-одиночка</quote> и <quote>огромная команда</quote>) в том, как <emphasis>преимущества</emphasis> соотносятся с <quote>ценой</quote> использования. Система, которую сложно понять или использовать, обойдётся дорого.</para>

      <para id="x_78">Проект для пятисот человек скорее всего развалится под собственным весом практически сразу, если в нём не используется система контроля версий и нет процесса разработки. В подобном случае даже говорить о цене использования контроля версий не имеет смысла, так как <emphasis>без</emphasis> неё провал практически неизбежен.</para>

      <para id="x_79">С другой стороны, проект <quote>на коленке</quote> для программиста-одиночки может показаться неудачным примером для использования системы контроля версий, потому как цена её использования наверняка будет сравнима с общей стоимостью всего проекта. Верно?</para>

      <para id="x_7a">Mercurial уникален тем, что поддерживает <emphasis>оба</emphasis> уровня разработки. Вы можете изучить основы всего за несколько минут и, благодаря минимальным накладным расходам, вы с лёгкостию сможете применять управление версиями к наималейшим из проектов. Его простота означает, что вам не придется удерживать в голове множество маловразумительных концепций или последовательностей команд вместо того, чтобы <emphasis>реально</emphasis> работать. В то же время, высокая производительность Mercurial и его распределённая природа позволит вам безболезненно увеличивать масштаб для управления большими проектами.</para>

      <para id="x_7b">Ни одна система контроля версий не поможет спасти скверно управляемый проект, но хорошие инструменты могут оказать значительное влияние на удобство работы над проектом.</para>

    </sect2>

    <sect2>
      <title>Множество названий для контроля версий</title>

      <para id="x_7c">Системы контроля версий используются в различных областях, так что их называют разными именами и сокращениями. Вот некоторые из наиболее распространенных вариаций с которыми вы можете столкнуться:</para>
      <itemizedlist>
	<listitem><para id="x_7d">Контроль ревизий (RCS, Revision control system)</para></listitem>
	<listitem><para id="x_7e">Конфигурационное управление (SCM, Software configuration management)</para></listitem>
	<listitem><para id="x_7f">Управление исходным кодом (Source code management)</para></listitem>
	<listitem><para id="x_80">Контроль исходного кода (Source code control)</para></listitem>
	<listitem><para id="x_81">Контроль версий (VCS, Version control system)</para></listitem></itemizedlist>
      <para id="x_82">Некоторые люди утверждают, что на самом деле у этих терминов разные значения, но на практике они настолько сильно пересекаются, что нет общепринятого или хотя бы полезного способа разделить их.</para>

    </sect2>
  </sect1>

  <sect1>
    <title>О примерах в этой книге</title>

    <para id="x_84">В этой книге довольно необычные примеры. Каждый пример <quote>живой</quote> &emdash; фактически, это результат исполнения скрипта, который выполняет приведённые команды Mercurial. Каждый раз, когда книга собирается из исходников, все примеры автоматически исполняются и их текущие результаты сравниваются с ожидаемыми.</para>

    <para id="x_85">Плюс такого подхода в том, что примеры всегда верны. Они описывают поведение в <emphasis>точности той</emphasis> версии Mercurial, которая указана в начале книги. Если я обновлю версию Mercurial, которую я описываю, и вывод какой-нибудь команды изменится &emdash; сборка книги не выполнится.</para>

    <para id="x_86">У этого подхода есть маленький недостаток, заключающийся в том, что даты и время, которые вы видите в примерах, <quote>слишком близки</quote> друг к другу, чего бы не происходило, если бы те же самые команды вбивал человек. Там, где человек может набрать не больше одной команды за несколько секунд, с соответствующим образом разнесёнными <quote>отпечатками времени</quote> (timestamps), мои автоматизированные примеры исполняют много команд за одну секунду.</para>

    <para id="x_87">Например, несколько последовательных коммитов в примере могут выглядеть исполненными в одну и ту же секунду. Вы можете это увидеть на примере использования команды <literal role="hg-ext">bisect</literal> в <xref linkend="sec:undo:bisect"/>.</para>

    <para id="x_88">Так что когда вы читаете примеры, не придавайте слишком большого значения датам или времени, которые вы увидите в результатах исполнения команд. Однако, <emphasis>будьте</emphasis> уверены, что поведение команд, которое вы видите, в целом верно и воспроизводимо.</para>

  </sect1>

  <sect1>
    <title>Тенденции в этой области</title>

    <para id="x_89">За последние четыре десятилетия в разработке и в использовании систем контроля версий &emdash; пока люди осваивали возможности своих инструментов и сталкивались с их ограничениями &emdash; можно проследить следующую тенденцию.</para>

    <para id="x_8a">Первое поколение начинало с управления одиночными файлами на индивидуальных компьютерах. Хотя эти инструменты имели большое преимущество над специализированным ручным управлением версиями, их блокирующая модель и зависимость от одного компьютера позволяли применять их лишь в тесных маленьких командах.</para>

    <para id="x_8b">Второе поколение ослабило эти ограничения переходом на сетевые архитектуры и комплексное управление проектами. По мере роста проектов появлялись новые проблемы. Если клиенты нуждались в очень частом взаимодействии с серверами, масштабирование этих серверов становилось сложной задачей для больших проектов. Ненадёжное соединение с сетью могло вообще не давать удалённым пользователям общаться с сервером. Когда проекты с открытым кодом стали давать всем анонимный доступ только на чтение, люди, не имеющие достаточных прав для внесения изменений, обнаружили, что не могут использовать инструменты для взаимодействия с проектом естественным образом, так как не могут вносить свои правки.</para>

    <para id="x_8c">Современное поколение инструментов контроля версий &emdash; по природе своей децентрализованное (peer-to-peer). Эти системы устранили зависимость от одного центрального сервера и позволили людям передавать данные контроля версий туда, где они действительно необходимы. Сотрудничество через Интернет, прежде ограниченное технологией, ныне стало вопросом выбора и согласия. Современные инструменты могут действовать и без сети, неограниченно и автономно, сетевое соединение требуется только при синхронизации изменений с другим репозиторием.</para>

  </sect1>
  <sect1>
    <title>Некоторые из преимуществ распределенных систем контроля версий</title>

    <para id="x_8d">Хотя инструменты распределённого контроля версий уже несколько лет так же надёжны и удобны, как и их аналоги предыдущего поколения, люди, использующие старые инструменты, ещё не осознали преимущества новых. Во многих отношениях распределённые инструменты блистают по сравнению с централизованными.</para>

    <para id="x_8e">Для отдельного разработчика распределённые инструменты практически всегда намного быстрее централизованных. Этому есть простое объяснение: централизованная утилита для многих обыденных операций должна общаться по сети, поскольку большинство метаданных хранятся в единственном экземпляре на центральном сервере. Распределённый инструмент хранит все свои метаданные локально. При прочих равных условиях общение по сети увеличивает накладные расходы использования централизованного инструмента. Не недооценивайте значимость шустрого, быстро реагирующего инструмента: вам доведётся провести массу времени, взаимодействуя с системою контроля версий.</para>

    <para id="x_8f">Распределённые инструменты безразличны к причудам вашей серверной инфраструктуры, опять же потому, что они создают дубликаты метаданных во множестве мест. Если вы используете централизованную систему, а ваш сервер воспламенится, то останется надеяться на то, что резервные копии надёжны, и что последнее создание их прошло успешно и не очень давно. С распределённым инструментом вам доступно множество резервных копий &emdash; на компьютере у каждого разработчика.</para>

    <para id="x_90">Надёжность вашего сетевого соединения будет влиять на распределённые системы значительно меньше, чем на централизованные. А использовать централизованную утилиту без сетевого соединения у вас даже не получится, за исключением нескольких сильно ограниченных команд. С распределённой системой отключение сетевого соединения во время работы вообще может пройти незамеченным. Единственное, что будет невозможным &emdash; запросы к репозиториям на других компьютерах, что происходит не так уж и часто по сравнению с другими операциями. Если вы состоите в группе разработчиков, находящихся на большом расстоянии друг от друга, это может быть значимым.</para>

    <sect2>
      <title>Преимущества для проектов с открытым исходным кодом</title>

      <para id="x_91">Если вы нашли открытый проект, над которым вам хотелось бы поработать, и проект использует распределённую систему контроля версий, вы находитесь на одной ступеньке с людьми, которые являются <quote>ядром</quote> проекта. Если они публикуют свои репозитории, вы можете незамедлительно копировать историю разработки, делать изменения и записывать их точно так же, как это делают полноправные участники проекта. Централизованную систему, напротив, придётся использовать в режиме <quote>только чтение</quote>, если только кто-нибудь не даст вам достаточно прав для фиксирования изменений на центральном сервере. До тех пор у вас не будет никакой возможности фиксировать изменения и они будут под риском искажения каждый раз при обновлении рабочей копии репозитория.</para>

      <sect3>
	<title>Ветвления &emdash; не проблема</title>

	<para id="x_92">Есть мнение, что распределённые системы контроля версий добавляют риска проектам с открытым исходным кодом, поскольку делают простым <quote>ветвление</quote> разработки проекта. Это случается, когда существуют разногласия во взглядах или отношениях между группами разработчиков, которые ведут к принятию ими решения о невозможности работать вместе. Тогда каждая сторона берёт более или менее полную копию исходного кода проекта и идёт в своём собственном направлении.</para>

	<para id="x_93">Иногда стороны решают объединиться и согласовать изменения. С централизованной системой процесс слияния изменений <emphasis>технически</emphasis> очень сложен и в основном должен быть произведён вручную. Вам придётся решать, чья история <quote>выиграет</quote>, и каким-то образом прививать изменения другой команды. Обычно при этом теряется история изменений одной или обеих сторон.</para>

	<para id="x_94">Распределённые системы поступают с ветвлением очень просто &emdash; они объявляют его <emphasis>единственным</emphasis> путём развития проекта. Каждое изменение, которое вы делаете, потенциально является точкой ответвления. Силой такого подхода является то, что инструмент должен быть действительно хорош в <emphasis>объединении</emphasis> веток, потому что ветки крайне важны: они всё время создаются.</para>

	<para id="x_95">Если каждый кусочек работы, делаемой всеми, всегда оформляется в терминах ответвления и слияния, тогда то, что мир открытого ПО называет <quote>ветвлением</quote>, становится <emphasis>исключительно</emphasis> социальной проблемой. Как бы то ни было, распределённые системы <emphasis>понижают</emphasis> вероятность ветвления:</para>
	<itemizedlist>
	  <listitem><para id="x_96">Они убирают социальное разделение, которое привнесли централизованные системы, между инсайдерами (теми, кто может вносить изменения) и аутсайдерами (теми, кто не может).</para></listitem>
	  <listitem><para id="x_97">Они упрощают воссоединение после социального ветвления, так как с точки зрения контроля версий это ничем не отличается от обычного слияния.</para></listitem></itemizedlist>

	<para id="x_98">Некоторые люди сопротивляются использованию распределённого контроля версий, потому что хотят сохранить за собой строгий контроль над своими проектами, и думают, что централизованные системы дадут им его. Тем не менее, если вы придерживаетесь таких убеждений, и при этом разрешаете публичный доступ к своему CVS/Subversion репозиторию, то знайте, что существует множество инструментов, позволяющих вытащить полную историю вашего проекта (пусть даже и медленно) и пересоздать её в таком месте, которое вы не сможете контролировать. Таким образом получается, что ваш контроль в этом случае иллюзорен, и в то же время вы потеряли возможность гибко сотрудничать с теми людьми, которые почувствовали себя вынужденными продублировать вашу историю или ответвиться от неё.</para>

      </sect3>
    </sect2>
    <sect2>
      <title>Преимущества для коммерческих проектов</title>

      <para id="x_99">Команды многих коммерческих проектов зачастую разбросаны по всему земному шару. Территориально удалённые от главного сервера разработчики могут сталкиваться с такими проблемами, как замедленная реакция на выполнение команд и, возможно, перерывы в доступности системы. Коммерческие системы контроля версий предлагают решение данной проблемы в виде расширений для удалённой репликации данных. Такие расширения как правило довольно дороги и сложны для администрирования. Распределённые системы изначально лишены подобных недостатков. Более того, можно установить несколько проектных серверов, скажем один в каждом офисе, для сокращения объёма избыточного трафика между репозиториями через дорогие каналы связи.</para>

      <para id="x_9a">Централизованные системы контроля версий как правило обладают ограниченной масштабируемостью. Падение дорогой централизованной системы под нагрузкой, вызванной одновременным обращением всего пары дюжин пользователей, не является чем-то необычным. Повторюсь, наиболее типичным решением проблемы будет дорогой и тяжелый механизм репликации. Так как нагрузка на главный сервер &emdash; даже если он единственный &emdash; для распределённого инструмента контроля версий во много раз меньше (потому что все данные реплицируются повсюду), один недорогой сервер может удовлетворять потребности гораздо более многочисленной команды разработчиков и для репликации с целью распределения нагрузки нужно лишь написать несложные скрипты.</para>

      <para id="x_9b">Если некоторые члены вашей команды работают <quote>в поле</quote>, разрешая проблемы на площадке заказчика, они также получают определённые преимущества от использования распределённой системы контроля версий. Инструмент позволит им строить кастомные сборки, пробовать различные исправления изолированно друг от друга, а также проводить эффективный поиск причины ошибки в среде заказчика с использованием истории версий. Всё это может быть выполнено без необходимости в постоянном соединении с внутренней сетью компании.</para>

    </sect2>
  </sect1>
  <sect1>
    <title>Почему следует остановить выбор на Mercurial?</title>

    <para id="x_9c">Mercurial обладает уникальным набором свойств, позволяющим выбрать его в качестве наиболее подходящей системы контроля версий:</para>
    <itemizedlist>
      <listitem><para id="x_9d">Прост в изучении и использовании</para></listitem>
      <listitem><para id="x_9e">Легковесный</para></listitem>
      <listitem><para id="x_9f">Превосходно масштабируется</para></listitem>
      <listitem><para id="x_a0">Легко настраивается под конкретные нужды</para></listitem></itemizedlist>

    <para id="x_a1">Если вы обладаете опытом в использовании систем контроля версий, вам потребуется меньше пяти минут, чтобы начать работать с Mercurial. Если же вы новичок, процесс знакомства не должен занять больше десяти минут. Mercurial предоставляет единообразную и последовательную систему команд и функций, что позволяет руководствоваться небольшим набором общих правил вместо того, чтобы учить массу исключений.</para>

    <para id="x_a2">В небольших проектах вы можете начать работу с Mercurial в считанные минуты. Создание новых веток и изменений, распространение изменений (как локально, так и по сети), операции с историей и статусом &emdash; всё это работает быстро. Mercurial старается быть незаметным и не путаться под вашими ногами, не требует от вас больших умственных усилий и совершает свои операции невероятно быстро.</para>

    <para id="x_a3">Mercurial применяется не только в маленьких проектах, его используют и в проектах с сотнями и тысячами разработчиков, проектах, которые содержат десятки тысяч файлов и сотни мегабайт исходного кода.</para>

    <para id="x_a4">Если вам не хватает базовой функциональности Mercurial, то её легко расширить. Mercurial хорошо подходит для задач скриптинга, его понятное устройство и реализация на языке Python позволяет легко добавлять новые возможности в виде расширений. Существует большое количество популярных и полезных расширений, охватывающих спектр задач от помощи в нахождении ошибок до улучшения производительности.</para>

  </sect1>
  <sect1>
    <title>Сравнение Mercurial с другими системами контроля версий</title>

    <para id="x_a5">Прежде чем вы продолжите чтение, вам следует уяснить, что этот раздел отражает мой опыт, интересы и (да, я осмелюсь сказать это) мои наклонности. Я использовал каждую из перечисленных ниже систем контроля версий в большинстве случаев в течение нескольких лет.</para>


    <sect2>
      <title>Subversion</title>

      <para id="x_a6">Subversion &emdash; популярная система контроля версий, разработанная с целью заменить CVS. Subversion имеет централизованную клиент/серверную архитектуру.</para>

      <para id="x_a7">Subversion и Mercurial имеют похожие команды для одних и тех же операций, так что если вы хорошо знаете одну из этих систем, вам легко будет научиться пользоваться другой. Обе системы портированы на все популярные операционные системы.</para>

      <para id="x_a8">Subversion до версии 1.5 не имел нормальной поддержки слияния. На момент написания книги возможность отслеживания слияний являлась относительно новой, с присущими <ulink url="http://svnbook.red-bean.com/nightly/en/svn.branchmerge.advanced.html#svn.branchmerge.advanced.finalword">сложностями и ошибками</ulink>.</para>

      <para id="x_a9">В каждой операции, производительность которой я измерял, Mercurial обладает большей производительностью, чем Subversion. Скорость больше в 2-6 раз, когда речь идет о <emphasis>локальном</emphasis> репозитории Subversion 1.4.3 (самый быстрый метод доступа). При более реалистичном варианте использования &emdash; сетевой репозиторий, Subversion находится в существенно худшем положении. В силу того, что команды Subversion должны взаимодействовать с сервером и при этом Subversion не имеет полезных средств репликации, производительность сервера и пропускная способность сети становятся узкими местами даже для некрупных проектов.</para>

      <para id="x_aa">Кроме того, Subversion требует дополнительное дисковое пространство для того, чтобы избежать сетевых запросов при выполнении некоторых операций: поиск модифицированных файлов (<literal>status</literal>) и отображение изменений (<literal>diff</literal>). В результате рабочая копия Subversion такого же размера (а то и больше) как репозиторий Mercurial и рабочий каталог вместе взятые, хотя репозиторий Mercurial содержит полную историю проекта.</para>

      <para id="x_ab">Subversion имеет широкую поддержку инструментария сторонних производителей. В этом отношении у Mercurial сейчас существенное отставание. Хотя разрыв сокращается, и некоторые GUI-утилиты для Mercurial превосходят свои аналоги для Subversion. Как и Mercurial, Subversion располагает отличным руководством пользователя.</para>

      <para id="x_ac">Из-за того, что Subversion не хранит историю изменений на клиенте, она хорошо подходит для управления проектами, содержащими большое количество двоичных файлов. Если вы внесете в несжимаемый десятимегабайтный файл 50 изменений, то дисковое пространство, использованное Subversion останется неизменным. Пространство, используемое любой из распределенных систем контроля версий, будет быстро увеличиваться пропорционально количеству изменений, потому что различия между правками большие.</para>

      <para id="x_ad">Кроме того, обычно трудно, а чаще даже невозможно слить разные версии двоичного файла. Subversion позволяет пользователю заблокировать файл, в результате пользователь на время получает эксклюзивные права на внесение изменений в него. Это может быть значительным преимуществом для проекта, в котором широко используются двоичные файлы.</para>

      <para id="x_ae">Mercurial может импортировать историю изменений из репозитория Subversion. Возможен и обратный процесс. Это делает возможным прощупать почву и использовать  Mercurial и Subversion одновременно, прежде чем решить, осуществлять переход или нет. Преобразование истории &emdash; пошаговый процесс, так что вы можете осуществить начальное преобразование, а потом вносить новые изменения.</para>


    </sect2>
    <sect2>
      <title>Git</title>

      <para id="x_af">Git &emdash; распределенная система контроля версий, которая была разработана для управления исходным кодом ядра Linux. Как и в случае с Mercurial, на начальный дизайн системы оказал влияние Monotone.</para>

      <para id="x_b0">Git предоставляет большой список команд, число которых в версии 1.5.0 достигает 139 уникальных единиц. Он имеет репутацию инструмента, сложного для изучения. В сравнении с Git, Mercurial делает упор на простоту.</para>

      <para id="x_b1">Что касается производительности &emdash; Git очень быстр. В некоторых случаях он быстрее, чем Mercurial (по крайней мере под Linux), а в других быстрее оказывается Mercurial. Однако под Windows как производительность, так и общий уровень поддержки, во время написания этой книги у Git гораздо хуже, чем у Mercurial.</para>

      <para id="x_b2">В то время как репозиторий Mercurial не требует операций по техническому обслуживанию, репозиторий Git требует частых ручных <quote>перепаковок</quote> собственных метаданных. Если этого не делать, производительность начинает падать, наряду с увеличением объёма занимаемого дискового пространства. Дисковый массив сервера, содержащего несколько Git репозиториев, по отношению к которым не выполняется строгое правило частой <quote>перепаковки</quote>, рано или поздно забивается под завязку, в результате чего процесс ежедневного резервного копирования легко может занимать более 24 часов. Только что <quote>запакованный</quote> репозиторий Git занимает немного меньше места, чем репозиторий Mercurial, но объём не перепакованного репозитория будет на несколько порядков больше.</para>

      <para id="x_b3">Ядро Git написано на языке С. Многие команды Git реализованы в виде Shell скриптов или скриптов на языке Perl и уровень качества данных скриптов сильно разнится. Я встречал несколько установок, в которых скрипты тупо продолжали выполнение, несмотря на наличие фатальных ошибок.</para>

      <para id="x_b4">Mercurial предоставляет возможность импорта истории версий из репозитория Git.</para>


    </sect2>
    <sect2>
      <title>CVS</title>

      <para id="x_b5">CVS, наверное, самая широко распространённая система контроля версий в мире. Благодаря почтенному возрасту, а также бардаку, царящему внутри, он очень слабо поддерживается уже много лет.</para>

      <para id="x_b6">CVS основан на централизованной, клиент-серверной архитектуре. Он не выполняет группировку файловых изменений в атомарные коммиты, тем самым позволяя людям легко <quote>сломать билд</quote>: один человек может успешно внести часть изменений в репозиторий, а затем оказаться заблокированным из-за необходимости выполнения слияния. Это приведёт к ситуации, когда остальные участники увидят только часть из тех изменений, которые они должны были увидеть. Данная особенность также влияет на то, как вы будете работать с историей изменений. Если вы хотите получить все изменения, которые один из членов команды внёс для решения определённой задачи, вам необходимо вручную исследовать описания и дату внесения изменений, произведённых для каждого затрагиваемого файла (если вы вообще знаете, какие файлы были затронуты).</para>

      <para id="x_b7">CVS оперирует довольно запутанными понятиями веток и меток, которые я даже не буду пытаться описать в данной книге. Он не поддерживает переименование как файлов, так и папок, благодаря чему репозиторий может быть достаточно легко повреждён. Так как внутренние механизмы контроля целостности практически отсутствуют, зачастую даже невозможно точно утверждать, повреждён ли репозиторий, и если да, то каким образом. Таким образом я бы не стал рекомендовать CVS для использования в любом из существующих или новых проектов.</para>

      <para id="x_b8">Mercurial предоставляет возможность импорта истории версий CVS. Тем не менее здесь есть несколько подводных камней, с которыми также сталкиваются любые другие инструменты иморта из CVS. Отсутствие атомарных изменений и версионирования иерархических данных файловой системы приводит к невозможности абсолютно точного реконструирования истории изменений CVS, поэтому в некоторых случаях используются допущения, а переименования обычно не отображаются. Так как множество задач по администрированию CVS должны выполняться вручную, что повышает риск ошибок, обычна ситуация, когда средство для импорта из CVS возвращает множество ошибок целостности репозитория (абсолютно нереальные даты изменения версий и файлы, которые остаются заблокированными на протяжении последнего десятка лет &emdash; это лишь пара из наименее интересных проблем, которые я могу вспомнить из собственного опыта).</para>

      <para id="x_b9">Mercurial предоставляет возможность импорта истории версий из репозитория CVS.</para>


    </sect2>
    <sect2>
      <title>Коммерческий инструментарий</title>

      <para id="x_ba">Perforce основан на централизованной, клиент-серверной архитектуре, при этом данные не кэшируются на клиентской стороне. В отличие от современных средств контроля версий, Perforce требует от пользователя запуска специальной команды, информирующей сервер о каждом файле, который человек собирается редактировать.</para>

      <para id="x_bb">Производительность Perforce вполне достаточна для небольших команд, но стремительно падает, если количество пользователей переваливает за пару дюжин. Умеренно большие установки Perforce требуют развёртывания прокси-серверов для распределения нагрузки, генерируемой пользователями.</para>


    </sect2>
    <sect2>
      <title>Выбор системы контроля версий</title>

      <para id="x_bc">За исключением CVS, все инструменты, перечисленные выше, имеют уникальные свойства, которые делают их подходящими для определённых стилей ведения проектов. Не существует инструмента, который мог бы быть использован в любой ситуации.</para>

      <para id="x_bd">Например, Subversion является хорошим выбором для работы с часто изменяющимися бинарными файлами, благодаря его централизованной архитектуре и поддержке блокировок на уровне файлов.</para>

      <para id="x_be">Лично меня в Mercurial привлекает простота, производительность и хорошая поддержка процесса слияния &emdash; этот превосходный набор служит мне уже несколько лет.</para>


    </sect2>
  </sect1>
  <sect1>
    <title>Переход с других систем контроля версий на Mercurial</title>

    <para id="x_bf">Mercurial поставляется с расширением под названием <literal role="hg-ext">convert</literal>, которое пошагово импортирует историю изменений из некоторых систем контроля версий. Под словом <quote>пошагово</quote> я подразумеваю, что вы за один раз можете сконвертировать историю проекта до определенной даты, а позже запустить преобразование еще раз для получения изменений, произошедших после первичной конвертации.</para>

    <para id="x_c0">Поддерживаются преобразование из следующих систем контроля версий:</para>
    <itemizedlist>
      <listitem><para id="x_c1">Subversion</para></listitem>
      <listitem><para id="x_c2">CVS</para></listitem>
      <listitem><para id="x_c3">Git</para></listitem>
      <listitem><para id="x_c4">Darcs</para></listitem></itemizedlist>

    <para id="x_c5">Кроме того, <literal role="hg-ext">convert</literal> может экспортировать изменения из Mercurial в Subversion. Это позволяет использовать Subversion и Mercurial параллельно, без риска потери данных.</para>

    <para id="x_c6">Команда <command role="hg-ext-convert">convert</command> проста в использовании. Просто укажите путь или URL исходного репозитория и имя целевого репозитория (необязательно), и она начнет работу. После первичного преобразования, запустите ту же самую команду для получения новых изменений.</para>
  </sect1>

  <sect1>
    <title>Краткая история контроля версий</title>

    <para id="x_c7">Самая известная из старых утилит контроля версий &emdash; SCCS (Source Code Control System, система контроля исходного кода), которую написал Марк Рочкайнд (Marc Rochkind) из Bell Labs, в начале 70-х. SCCS оперировала отдельными файлами и требовала, чтобы каждый человек, работающий над проектом, имел доступ к общему рабочему пространству, существовавшему в единственном экземпляре. Только один человек мог одновременно редактировать файл в один момент времени; конфликты доступа к файлам разрешались блокировками. Обычной ситуацией было забывание снятия блокировки после редактирования, что запрещало доступ к файлу другим людям без помощи администратора.</para>

    <para id="x_c8">Вальтер Тичи (Walter Tichy) разработал свободную альтернативу SCCS в начале 1980-х; он назвал свою программу RCS (Revision Control System, система контроля ревизий). Подобно SCCS, RCS требовала от разработчиков как работы в едином разделяемом рабочем пространстве, так и блокировки файлов для предотвращения одновременного изменения файлов разными людьми.</para>

    <para id="x_c9">Позднее, в 1980-х же годах, Дик Грюн (Dick Grune) использовал RCS как основу для набора shell-скриптов, изначально названных cmt, а позднее переименованных в CVS (Concurrent Versions System, система одновременных версий). Крупное нововведение CVS заключалось в том, что она позволяла разработчикам работать одновременно и, в некоторой степени, независимо в их личных рабочих пространствах. Этими-то пространствами и предотвратились постоянные наступания разработчиков друг другу на пятки, которое было обычным делом в SCCS и RCS. Каждый разработчик имел копию каждого файла проекта, разработчики могли модифицировать свои копии независимо. Им приходилось объединять собственные правки только перед отсылкою изменений в центральное хранилище.</para>

    <para id="x_ca">Брайан Берлинер (Brian Berliner) взял первоначальные скрипты Грюна и переписал их на Си, выпустив в 1989 году код, который впоследствии развился в современную версию CVS. CVS в дальнейшем приобрела возможность работать по сети, обретя клиент-серверную архитектуру. Архитектура CVS является централизованной: только на сервере есть копия истории проекта. Клиентские рабочие копии содержали только экземпляры файлов последней версии и небольшие метаданные для определения местонахождения сервера. Система CVS достигла небывалого успеха: вероятно, она является самой широко используемой системой контроля версий в мире.</para>

    <para id="x_cb">В начале 1990-х годов Sun Microsystems разработала раннюю распределённую систему контроля версий, называвшуюся TeamWare. Каждая рабочая копия TeamWare содержала полную копию истории изменений проекта. Понятие центрального репозитория в TeamWare отсутствовало как таковое. (Подобно CVS, использовавшей RCS для хранения истории, TeamWare использовала SCCS.)</para>

    <para id="x_cc">Шли 1990-ые, росла осведомлённость о нескольких проблемах CVS. Система записывает одновременные изменения нескольких файлов раздельно, а не группирует их в одну логически атомарную операцию. Способ управления файловой иерархией не очень хорош: нетрудно устроить в репозитории беспорядок, переименовывая файлы и каталоги. Более того, исходные коды CVS непросто понимать и поддерживать, что сделало практически непреодолимым <quote>болевой порог</quote> исправления этих архитектурных проблем.</para>

    <para id="x_cd">В 2001 году Джим Бланди (Jim Blandy) и Карл Фогель (Karl Fogel) &emdash; два разработчика, прежде работавшие над CVS &emdash; начали проект по её замене таким средством, которое имело бы архитектуру получше и код почище. Результат &emdash; Subversion &emdash; не отошёл от централизованной клиент-серверной модели CVS, но добавил атомарные коммиты нескольких файлов, лучшее управление пространствами имён и другие возможности, которые сделали Subversion более удобным средством работы, нежели CVS. Со времени выхода первой версии Subversion быстро обретал популярность.</para>

    <para id="x_ce">Более или менее одновременно, Грейдон Хоар (Graydon Hoare) начал работать над амбициозной системой контроля версий, которую назвал Monotone. Эта система не только устраняет множество проблем внутреннего устройства CVS и имеет распределённую архитектуру, но и идёт далее нескольких прежних (и последующих) систем контроля версий в некоторых своих нововведениях. Monotone использует криптографические хеши в качестве идентификаторов и имеет неотъемлемое представление о <quote>доверии</quote> коду из различных источников.</para>

    <para id="x_cf">Жизнь Mercurial началась в 2005 году. В то время как некоторые аспекты его архитектуры были созданы под влиянием Monotone, Mercurial сосредоточен на простоте использования, высокой производительности и масштабируемости до очень больших проектов.</para>
  </sect1>
</chapter>

<!--
local variables: 
sgml-parent-document: ("00book.xml" "book" "chapter")
end:
-->