Используя git/mercurial для проектов с непрерывным рефакторингом?

Я пытаюсь понять, действительно ли у меня есть случай использования git/mercurial.

Проекты, над которыми я работаю, - проекты java и С#, обычно с 5-20 людьми, работающими в общая цель ( "релиз" ). Большинство разработчиков - это профессиональные разработчики, которые refactor code все время. Поэтому, когда типичное ядро linux имеет большое количество относительно независимые изменения в отдельных файлах, мы имеем постоянный поток изменений рефакторинга - часто ударяя много файлов и много кода. Никто не боялся изменить код здесь.

Теперь с подрывной деятельностью мы решаем это, оставаясь очень близко к SVN HEAD. Некоторые из нас даже автоматизированный svn-up, который запускается на трансляторе Jabber сервера сборки. Большинство из нас также научились (или научиться очень быстро), как планировать нашу работу, чтобы оставаться рядом с SVN HEAD. Если вы проводите крупный рефакторинг, мы постепенно сгибайте исходное дерево в новом направлении, вместо того, чтобы уходить слишком долго. Иногда вы просто планируете рефакторинга и начать работу в менее спорных областях. Через несколько лет Таким образом, он становится второй натурой. Большинство из нас просто не оставляют "зону комфорта" меньше, чем 2 часа от головы svn. Автоматическая сборка и svn head - это проект "импульс", и нам это нравится.

Конечно, мы отбрасываем каждый релиз, но количество обратных потоков от ветки релиза до ствола сокращается вниз достаточно быстро, чтобы быть незначительным (у нас есть достойный охват тестирования). Запуск в течение нескольких дней/недель с отдельными ветвями исходных звуков как то, что мы активно хотим обескуражить, и это просто не происходит очень часто.

Оба git и меркуриальный звуковой путь круто, git немного больше, так как я больше типа Макгивера, чем тип Джеймса Бонда. Но когда дело доходит до построения случая для фактического переключения, мне кажется, что мы с Линусом живем на двух разных планетах. Большую часть времени мы хотим, чтобы наши команды сосредоточились на HEAD.

Как git улучшить контроль над версиями? Как git позволит мне улучшить мой процесс? Я диверсант диверсии?

Ответ 1

В терминах менталитета иногда бывает полезно создать мягкую ветвь, выполнить все изменения в мягкой ветки, проверить результат изменений в мягкой ветки, а затем, когда мягкая ветвь является "полным", реинтегрируйте его с основной ветвью локально, повторно протестируйте его и затем распространите.

Это в некоторых случаях лучше, чем устремленная голова, потому что у вас нет постоянного прерывания существования кода отладки других, что заставляет ваш код добавлять ненужные ошибки.

Это также означает, что вы можете совершать более часто, давая более полную историю, потому что коммиты не мгновенно появляются повсюду, создавая проблемы.

Кроме того, при согласовании мягкой ветки с общей основной линией вы увидите хороший полный набор изменений, показывая вам как все ваши коллективные изменения, так и все их коллективные изменения, которые открывают двери для приятных возможностей просмотра кода,

Кроме того, с точки зрения тестирования, если у вас есть более мягкие ветки, вы можете запускать тесты на мягких ветвях, прежде чем слить их обратно в основную ветвь, и иметь стандарт, по которому ветка не объединяется обратно в основную ветвь, пока она не будет

Прошедшие тесты
Прошедшие тесты после изменения основных ветвей были согласованы с мягкой веткой

Таким образом, вы получаете дополнительную гарантию качества кода, так как ваша основная ветвь сотрудничества является излишне скрипучей, потому что на этом не разрешен провал кода.

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

Но буду ли я постоянно обновлять центральная репо голову в мою softbranch? Это действительно суть моего Проблема

Красота системы веток - вы можете потянуть "все, что считалось стабильным другими", в свою местную копию по мере необходимости.

"Непрерывное обновление" становится ненужным, потому что у вас нет одинаковых проблем.

a  b   center
         |
         |
         /      Key:   / - | \   = Flow
/----<---|             < >       = Flow Directions
|  /--<--/             *         = Commit 
*  |     |             T         = Test
|  *     |             M         = Merging with "Current" state of common branch
*  |     |             C         = Tests Complete and Current state is "sane"
|  *     |
T  |     |
|  T     |
|  C     |
|  |/-<--/
*  M     |
|  T     |
*  C     |
|  \--->-\
*  /---<-/
T  |     |
C  *     |
|/-----<-/
M  |     |
T  *     |
|  T     |
*  C     |
|  |/-<--/
*  M     |
T  T     |
C  \-->--\
|/---<---/
M        |
T        |
C        |
\---->---\
         |

Кроме того, из-за того, как работает система, позже это также может произойти:

a  b   center
|  |     |
T  |     |
C  *     |
|/</     |
M  |     |
|  *     |
T        |
C        |
|/----<--/
M        |
T        |
C        |
\-->-----\
         |

Вся концепция их "голова" в таком сценарии исчезает. Это десятки голов, которые вы видите, склонны к перспективам.

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

В сущности, "Постоянное обновление моей softbranch от mainbranch", концептуально бессмысленно. Потому что на самом деле будут изменения, которые еще не представлены в основной части, и когда вы узнаете, что их толкнули или нет? SVN Дает вам эту ложную иллюзию "сингулярного" состояния кода, когда на самом деле мгновенный один пользователь открывает файл в своем текстовом редакторе, они на самом деле создали очень короткую жизнь, мягкую ветвь, изменение, которое происходит, о котором никто не знает, и для того, чтобы эта иллюзия была устойчивой, как вы думаете, она работает, по сути, пользователь должен совершать после каждого персонажа, что вряд ли практично. Таким образом, на самом деле люди привыкают к тому, что разные локации "не синхронизируются" друг с другом, и изучают способы их решения, поэтому это уже не проблема.

Кроме того, "постоянное обновление моего дерева всеми изменениями elses" имеет основную проблему, в связи с чем у вас слишком много отвлекающих факторов, вас постоянно бомбардируют все, что делают все остальные, и если они делают серия из 1 строки обязывает проверять что-то, что они не могут проверить на своей собственной машине, тогда у вас есть кошмар с постоянно меняющимся файлом, и пользователи, видящие кажущиеся случайными изменения, не могут их понять.

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

Если у вас есть сомнения

Начните с чего-то простого и не переходите на холодную индейку, некоторые из концепций в DSCM могут быть немного сложными (я видел, как многие трагические неудачи понимают концепцию вертикально уложенных мягких ветвей), переместите небольшая несущественная часть кодовой базы до Git/Mercurial и играйте с ней на некоторое время, экспериментируйте с преимуществами и тем, что она может сделать. Там нет лучшего доказательства, чем испытывать его самостоятельно, и все мои прекрасные объяснения вряд ли будут сообщать то, что вам нужно понять, и их можно узнать только, попробовав его, и провалив несколько раз (поскольку сбой является ключевой частью обучения)

Ответ 2

То, как ваша команда использует Subversion, означает, что происходит довольно много усилий по слиянию. Почти каждый раз, когда член команды обновляется до последней основной линии, они объединяют свою рабочую копию с последней основной линией, даже если на этом этапе они не совершают собственных изменений. Накладные расходы на слияние имеют тенденцию к тому, что они являются результатом ставки фиксации и количества членов команды, а так как коэффициент фиксации зависит от количества членов команды, ваши служебные данные управления исходным кодом - O (N ^ 2).

В модели Mercurial/ Git это объединение будет распространено среди команды. Если вы регулярно вытаскиваете списки изменений у всех, то часто вы обнаружите, что другие уже выполнили почти всю работу слияния, которую вы, возможно, должны были сделать. И в тех случаях, когда слияние что-то сломало, часто люди уже исправили это. Согласование пары ветвей нужно делать только один раз, и поскольку скорость генерации новых ветвей пропорциональна количеству членов команды, служебные данные управления исходным кодом - O (N).

Я ожидаю, что 20 разработчиков, работающих близко к голове в одном филиале, скорее всего, будут вовлечены в справедливое количество слияний (борьба с конфликтами и борьба с регрессами из-за независимого развития), поэтому я был бы удивлен, если бы вы попробовал Mercurial/ Git и не нашел полезной победы в производительности. Как вы думаете, вы могли бы управлять 100 разработчиками с вашим текущим прогрессом? Я бы оценил количество разработчиков ядра Linux в 4000, и все же они получают много всего, и общая нагрузка на исходный код должна быть приемлемой.

Пока ваша система управления исходным кодом отслеживает общее происхождение, слияния часто являются автоматическими. Каждое слияние имеет шанс либо быть текстовым конфликтом, либо нарушать сборку и тесты из-за взаимодействия между изменениями; тем меньше слияний вы должны сделать меньше времени, которое вам придется потратить на любую проблему.

Следовательно, действительно большая победа в том, что пользователи Mercurial/ Git больше не боятся ветвей. До BitKeeper (инструмент, который действительно вводил этот способ работы, насколько мне известно) длительные ветки были таймингами, иногда взрываясь, и на неделю вылечились. Теперь мы можем без колебаний колебаться, с уверенностью, что позже мы сможем слиться. В здоровой команде другие могут видеть ваши ветки в процессе и объединять их с собой и позже приложить свои усилия, если они посчитают это целесообразным. В централизованной модели, если у каждого разработчика было 3 или 4 ветки, и я исправляю, говоря это O (N ^ 2), то вы только увеличили накладные расходы на управление исходным кодом на 3ish ^ 2, т.е. на порядок, что, вероятно, достаточно, чтобы реально повредить здоровью, богатству и счастью. Это основная причина, по которой члены команды (и менеджеры), как правило, опасаются веток в централизованных системах и работают над их минимизацией.

Ответ 3

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

Ответ 4

Дал вам один голос за хороший юмор в слове svn/dinosaur.

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

Ответ 5

Я считаю, что меркуриал велик. Особенно с TortoiseHg.

Одна из вещей, которую я нахожу наиболее полезной, - это возможность поделиться разработкой функций только с основной командой.

Предположим, что у всей команды 20 человек, но вы только хотите протестировать и развить одну функцию с командой из 3-4 человек, прежде чем совершать в основной репозиторий. Затем с помощью Mercurial вы можете просто синхронизировать код между 3-4-кодировщиком, пока вы не будете удовлетворены до фиксации в основном репозитории.

Или вы даже можете быть своей командой, например. когда вы хотите протестировать свой код на нескольких платформах, прежде чем переходить в основной репозиторий.

Ответ 6

то, что вы описали в SVN, может быть выполнено с помощью git/mercurial