Почему в Mercurial проще выполнять ветвление и слияние, чем в Subversion?

Обработка множественных слияний с ветвями в Subversion или CVS - лишь одна из тех вещей, которые необходимо испытать. В Mercurial (и, возможно, в любой другой распределенной системе) чрезвычайно легче отслеживать ветки и слияния, но я не знаю почему. Кто-нибудь еще знает?

Мой вопрос проистекает из того факта, что с Mercurial вы можете применить рабочую практику, аналогичную той, что используется в центральном репозитории Subversions / CVS, и все будет работать нормально. Вы можете выполнить несколько слияний в одной и той же ветке, и вам не понадобятся бесконечные клочки бумаги с номерами коммитов и именами тегов.

Я знаю, что последняя версия Subversion имеет возможность отслеживать слияния с ветками, поэтому вы не получите такой же сложности, но это была огромная и серьезная разработка с их стороны, и она по-прежнему не делает всего того, что сделала бы команда разработчиков. нравится это делать.

Должна быть принципиальная разница в том, как все это работает.

Стоит ли изучать PHP в 2023-2024 годах?
Стоит ли изучать PHP в 2023-2024 годах?
Привет всем, сегодня я хочу высказать свои соображения по поводу вопроса, который я уже много раз получал в своем сообществе: "Стоит ли изучать PHP в...
Поведение ключевого слова "this" в стрелочной функции в сравнении с нормальной функцией
Поведение ключевого слова "this" в стрелочной функции в сравнении с нормальной функцией
В JavaScript одним из самых запутанных понятий является поведение ключевого слова "this" в стрелочной и обычной функциях.
Приемы CSS-макетирования - floats и Flexbox
Приемы CSS-макетирования - floats и Flexbox
Здравствуйте, друзья-студенты! Готовы совершенствовать свои навыки веб-дизайна? Сегодня в нашем путешествии мы рассмотрим приемы CSS-верстки - в...
Тестирование функциональных ngrx-эффектов в Angular 16 с помощью Jest
В системе управления состояниями ngrx, совместимой с Angular 16, появились функциональные эффекты. Это здорово и делает код определенно легче для...
Концепция локализации и ее применение в приложениях React ⚡️
Концепция локализации и ее применение в приложениях React ⚡️
Локализация - это процесс адаптации приложения к различным языкам и культурным требованиям. Это позволяет пользователям получить опыт, соответствующий...
Пользовательский скаляр GraphQL
Пользовательский скаляр GraphQL
Листовые узлы системы типов GraphQL называются скалярами. Достигнув скалярного типа, невозможно спуститься дальше по иерархии типов. Скалярный тип...
93
0
11 893
6
Перейти к ответу Данный вопрос помечен как решенный

Ответы 6

У меня только опыт работы с Subversion, но я могу сказать вам, что экран слияния в TortoiseSVN ужасно сложен. К счастью, у них есть кнопка пробного запуска, чтобы вы могли убедиться, что все делаете правильно. Сложность заключается в настройке того, что вы хотите слить с чем. Как только вы настроите эту настройку для слияния, слияние обычно проходит нормально. Затем вам нужно разрешить все конфликты и затем зафиксировать вашу объединенную рабочую копию в репозиторий.

Если Mercurial может упростить настройку слияния, то я могу сказать, что это упростит слияние на 100%, чем Subversion.

Я предполагаю, что это может быть частично связано с тем, что Subversion имеет идею центрального сервера вместе с абсолютной временной шкалой изменений. Mercurial действительно распределен и не имеет такой привязки к абсолютной временной шкале. Это позволяет проектам Mercurial формировать более сложные иерархии ветвей для добавления функций и циклов тестирования по подпроектам, однако теперь командам нужно гораздо более активно следить за слияниями, чтобы оставаться в курсе, поскольку они не могут просто нажать на обновление и покончить с ним. .

В Subversion (и CVS) репозиторий - это прежде всего. В git и mercurial нет одинаковой концепции репозитория; здесь изменения - центральная тема.

Я не особо задумывался о том, как вы бы это реализовали, но мое впечатление (основанное на горьком опыте и большом количестве прочитанного) заключается в том, что именно эта разница делает слияние и ветвление намного проще в системах, не основанных на репозиториях.

Потому что Subversion (по крайней мере, версия 1.4 и ниже) не отслеживает, что было объединено. Для Subversion слияние в основном такое же, как и любая фиксация, в то время как в других системах контроля версий, таких как Git, то, что было слито, запоминается.

Ответ принят как подходящий

In Subversion (and CVS), the repository is first and foremost. In git and mercurial there is not really the concept of a repository in the same way; here changes are the central theme.

+1

Проблемы с CVS / SVN возникают из-за того, что эти системы выполняют нет помните отцовство изменений. В Git и Mercurial у фиксации может быть не только несколько дочерних элементов, но и несколько родители!

Это можно легко увидеть с помощью одного из графических инструментов gitk или hg view. В следующем примере ветвь №2 была разветвлена ​​от №1 в commit A, и с тех пор был объединен один раз (в M, объединен с фиксацией B):

o---A---o---B---o---C         (branch #1)
     \       \
      o---o---M---X---?       (branch #2)

Обратите внимание, что A и B имеют двух дочерних элементов, тогда как M имеет два родители. Эти отношения - это записанный в репозитории. Скажем, сопровождающий ветка №2 теперь хочет объединить последние изменения из ветки №1, они могут введите команду, например:

$ git merge branch-1

и инструмент автоматически узнает, что основание - B, потому что он был записан в коммите M, предке кончика # 2 - и что он должен объединить все, что произошло между B и C. CVS не записывает эту информацию, как и SVN до версия 1.5. В этих системах граф будет выглядеть так:

o---A---o---B---o---C         (branch #1)
     \    
      o---o---M---X---?       (branch #2)

где M - это просто гигантский "сжатый" коммит всего, что произошло между A и B, применяется поверх M. Обратите внимание, что после того, как действие выполнено, есть нет следов оставили (кроме потенциально удобочитаемых комментариев) того места, где M сделал исходить из, ни коммиты Как много не были свернуты вместе - что делает история куда более непонятная.

Что еще хуже, выполнение второго слияния становится кошмаром: нужно понять какая база слияния была во время первого слияния (и от одного имеет до знать что в первую очередь произошло слияние!), то предоставить эту информацию инструменту, чтобы он не пытался воспроизвести A..B на вершина М. Все это достаточно сложно при работе в тесном сотрудничестве, но просто невозможно в распределенной среде.

Связанная с этим проблема заключается в том, что нет способа ответить на вопрос: "действительно ли X содержат B? ", где B - это потенциально важное исправление ошибки. Итак, почему бы просто не записать эту информацию в коммит, поскольку это известен во время слияния!

П.-С. - У меня нет опыта работы с возможностями записи слиянием SVN 1.5+, но рабочий процесс кажется намного сложнее надуманный, чем в распределенных системах. Если это действительно так, то, вероятно, потому, что - как уже упоминалось в комментарии выше - упор делается на организацию репозитория, а не на сами изменения.

SVN 1.5+ действительно помещает свойство SVN в коммит слияния M, в котором перечислены слитые коммиты, которые он содержит, другими словами A-B. Значит, у вас такая же информация.

Simon D 11.03.2010 14:27

Что-то вроде. Технически отслеживание слияния SVN сродни тому, что Git называет «подбором вишен», с дополнительным волшебством, облегчающим работу пользователя; он семантически отличается от того, что делают Git, Hg и Bzr при слиянии. Думаю, на практике это не имеет большого значения, если вам не важен DAG (eagain.net/articles/git-for-computer-scientists).

Damien Diederen 22.03.2010 13:35

Горе, что нет кнопки +100. Спасибо.

Charlie Flowers 05.02.2011 12:07

Я предполагаю, что функция SVN 1.5, о которой вы говорите, - это использование свойства svn:mergeinfo?

MatrixFrog 10.03.2011 10:34

@MatrixFrog: Да, именно это и делает svn:mergeinfo.

sleske 28.10.2011 13:34

@CharlieFlowers Всегда можно наградить наградой!

Josiah Yoder 26.02.2021 23:20

Не тронутый ни одним из уже предоставленных ответов, Hg предлагает превосходные возможности слияния, потому что он использует больше информации при слиянии изменений (hginit.com):

For example, if I change a function a little bit, and then move it somewhere else, Subversion doesn’t really remember those steps, so when it comes time to merge, it might think that a new function just showed up out of the blue. Whereas Mercurial will remember those things separately: function changed, function moved, which means that if you also changed that function a little bit, it is much more likely that Mercurial will successfully merge our changes.

Конечно, запоминание того, что было объединено последним (вопрос, о котором говорится в большинстве ответов, представленных здесь), также является огромной победой.

Однако оба улучшения сомнительны, поскольку subversion 1.5+ хранит дополнительную информацию о слиянии в форме свойств subversion: эта информация доступна, нет очевидной причины, по которой слияние subversion не могло реализовать слияние так же успешно, как Hg или Git. Я не знаю, правда ли, но похоже, что разработчики подрывной деятельности пытаются обойти эту проблему.

Другие вопросы по теме