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

Наша политика при доставке новой версии - создать филиал в нашей VCS и обработать его в нашей команде QA. Когда последний дает зеленый свет, мы отмечаем и выпускаем наш продукт. Филиал хранится для получения (только) исправлений ошибок, чтобы мы могли создавать технические выпуски. Эти исправления ошибок впоследствии объединяются в туловище.

В течение этого времени соединительная линия видит основную работу по разработке и потенциально подвержена изменениям рефакторинга.

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

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

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

Как вы справляетесь с этим напряжением?

Спасибо.

Ответ 1

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

Мое предпочтение состояло в том, чтобы позволить основной магистрали продолжать свою нормальную скорость и не удержаться, потому что в среде, где тайминги релиза были важны коммерчески, я никогда не мог аргументировать, что мы должны позволить коду стабилизироваться ( "что, вы имеете в виду, что вы выпустили его в нестабильном состоянии?" ).

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

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

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

Добавление: Следует также упомянуть, что необходимо было списать ветвь в виде отдельных этапов в расписание выпуска основной ветки. Не недооценивайте объем работы, которая может возникнуть при объединении ваших веток, если у вас есть коллектив трудолюбивых разработчиков, выполняющих свои функции по реализации.

Ответ 2

В тех случаях, когда я работаю, мы создаем временные, недолговечные (менее суток - несколько недель) рабочие ветки для каждого нетривиального изменения (добавление функции или исправление ошибок). Багажник стабилен и (в идеале) потенциально доступен для разблокировки; только сделанные предметы объединяются в него. Все, что происходит от ствола, каждый день сливается в рабочие отрасли; это может быть в значительной степени автоматизировано (мы используем Hudson, Ant и Subversion). (Этот последний момент, потому что обычно лучше разрешать любые конфликты раньше, чем позже, конечно.)

В текущей модели, которую мы используем, в значительной степени повлияла отличная статья (которую я подключил раньше) Хенриком Книбергом: Контроль версий для нескольких гибких групп.

(В нашем случае у нас есть две команды scrum, работающие над одной базой кода, но я подумал, что эта модель может быть полезной даже с одной командой.)

Есть некоторые накладные расходы по поводу дополнительного разветвления и слияния, но не слишком много, действительно, когда вы привыкнете к нему и поправитесь с инструментами (например, svn merge --reintegrate удобен). И нет, я не создаю временную ветвь всегда, например. для небольших рефакторингов с низким уровнем риска (не связанных с основными предметами, которые в настоящее время работают), которые могут быть легко завершены с помощью одной фиксации для магистрали.

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

Я не уверен, отвечает ли это на ваш вопрос напрямую, или если вы можете применить это в своей среде (с отдельной командой QA и всеми), но, по крайней мере, я могу сказать, что описанное вами напряжение не существует для нас и мы можем реорганизовать каждый раз. Удачи!

Ответ 3

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

Непрерывная интеграция
Автоматизированные функциональные тесты (я полагаю, вы уже считаете с модульными тестами)
Автоматическая доставка

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

С автоматическими функциональными тестами вы можете протестировать свое приложение одним нажатием кнопки. Как правило, поскольку эти тесты занимают больше времени, они проводятся ночью. При этом классическая роль управления версиями начинает терять значение. Вы не принимаете решение о том, когда выпустить на основе версии и ее зрелости, в большей степени это деловое решение. Если вы внедрили модульное и функциональное тестирование, и ваша команда отправляет проверенный код, руководитель должен всегда находиться в состоянии, которое может быть выпущено. Ошибки постоянно обнаруживаются и фиксируются и освобождаются, но это уже не циклический процесс, его непрерывный.

У вас, вероятно, будет два типа хулителей, поскольку это подразумевает изменение некоторых давно укоренившихся практик. Во-первых, смена парадигмы непрерывной доставки кажется противоречащей управленцам. "Арент, которому мы рискуем отправить крупную ошибку?" Если вы посмотрите на дистрибутивы Linux или Windows, это именно то, что они делают: продвижение выпусков к клиентам. И поскольку вы считаете, что с набором автоматизированных тестов, опасности еще больше уменьшаются.

Далее, команда или отдел QA. (Некоторые утверждают, что проблема в их существовании сама по себе!) Они, как правило, будут отвлекаться на автоматизацию тестов. Это означает изучение нового, а иногда и сложного инструмента. Здесь лучше всего проповедовать, делая это. Наша команда разработчиков начала работать над непрерывной интеграцией и в то же время написала набор функциональных тестов с Selenium. Когда команда ОК увидела инструмент в действии, было трудно противостоять его реализации.

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

Ответ 4

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

С распределенным контролем версий слияния просты и работают нормально. Таким образом, вы можете иметь стабильную ветку и ветку разработки или создавать долгоживущие ветки для своей команды QA, где они проверяют вещи перед развертыванием, или вы можете создавать ветки короткоживущих, чтобы опробовать новые идеи и посмотреть, как они работают.

Не пробовал еще, хотя...

Ответ 5

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

Ответ 6

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

Убедиться, что мы только отделимся от очень стабильного кода, вероятно, поможет, но не будет так просто...: (