Как вы справляетесь с интеграцией кода из нескольких веток / разработчиков каждого спринта?

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

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

Как мы можем уменьшить эту нагрузку и облегчить объединение нашего кода? С моей точки зрения, если PO или SM приоритизируют истории более эффективным образом, чтобы у нас не было такого рода зависимостей в одном спринте, это может решить некоторые из проблем. Как все остальные справляются с этим? Или это только часть процесса?

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

Когда разработчик завершает свою работу, он создает запрос на извлечение . Когда одобрено, это объединено в developветвь.

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

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

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

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

• Держите свои ветви недолговечными (кажется, что вы уже делаете это).
• Пусть результаты вашего теста говорят сами за себя.
• Не ждите конца спринта.

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

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

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

Еще один момент, который я считаю достаточно важным, чтобы оставить его до последнего абзаца. Я предлагаю вам запускать ручные тесты над вашими ночными сборками, а не ждать до конца спринта. Разработчики должны объединиться, как только функция будет завершена, чтобы ее можно было интегрировать, развертывать и тестировать как можно скорее.

не

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

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

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

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

Это позволяет вам объединить ваши изменения на ранних этапах в одну masterили в вашу совместную ветку разработки, ничего не нарушая. Другие разработчики могут затем объединить эти изменения обратно в свои ветви функций (или соответственно изменить их ветви).

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

Флаги функций имеют дополнительные преимущества (например, они облегчают проведение A / B-тестов). Смотрите эту статью Мартина Фаулера для получения дополнительной информации.

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

После завершения регрессионного и интеграционного тестирования мы легко перемещаем готовые к использованию функции в ветку релиза.

Если все идет хорошо, мы объединяем ветку релиза с мастер веткой.

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

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

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