Як ви обробляєте інтегруючи код з декількох гілок / розробників кожного спринту?

Щойно вийшов з ретро-дзвінка, де розробники висловлювали стурбованість інтеграцією своїх історій у головну гілку кожного спринту. Всі розробники кодують всередині своєї власної гілки, і наприкінці спринту вони всі об'єднуються в одну головну гілку.

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

Як ми можемо зменшити цей тягар і полегшити злиття нашого коду? З моєї точки зору, наявність ПО або СМ розставляє пріоритети розповідей більш ефективно, щоб у нас не було подібних залежностей в одному спринті, можливо, вирішити деякі проблеми. Як усі інші вирішують це? Або це лише частина процесу?

Якщо ви використовуєте Git, кожен розробник буде перетягувати його з developвласної гілки функцій, щоб гарантувати, що вони не надто далеко від поточної базової лінії. Вони можуть робити це щодня, так що завдання, що займають більше декількох днів, залишаються синхронізованими та злиттями, вирішуються, поки вони ще невеликі.

Коли розробник закінчує свою роботу, вони створюють запит на тягу . Коли це буде затверджено, він об'єднується у developвідділення.

developФілія завжди повинен мати робочий код, і бути готовими до випуску в будь-який час. Коли ви фактично робите реліз, ви зливаєтесь developу нього masterта додаєте тег до нього.

Якщо у вас хороший сервер безперервної інтеграції, він буде будувати кожну гілку, коли буде зареєстровано зміни - особливо для запитів на виклик. Деякі сервери побудови інтегруються з вашим сервером Git для автоматичного затвердження або відхилення запиту на витяг, якщо збірка не вдається або автоматичні тести не вдається. Це ще один спосіб пошуку потенційних помилок інтеграції.

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

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

• Тримайте свої гілки недовговічними (це здається, ви вже робите це).
• Нехай ваші результати тесту говорять самі за себе.
• Не чекайте закінчення спринту.

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

Потім, після завершення злиття, ви можете разом перевірити звіт про тест автоматизації та переконатися, що все було інтегровано успішно.

Я погоджуюся з однією з інших відповідей, де автор заявив, що Git PRs вирішить цю проблему, змусивши кожного розробника об'єднати власну роботу.

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

Не варто

Залежно від вашої мови та файлів, які ви редагуєте, можливо, не має сенсу кожен розробник редагувати їх у своїй гілці. Наприклад, у C # я знайшов, що найкраще одночасно редагувати будь-які файли дизайнера інтерфейсу лише одна людина. Це автогенеровані файли, і тому код іноді переміщується без видимих ​​причин - і це спричиняє загрозу для більшості інструментів злиття.

Це означає, що деякі історії можуть блокувати інші історії, поки робота інтерфейсу не буде виконана. І / або створена нова історія для простого компонування інтерфейсу користувача, а інші історії реалізують функціональність. Або, можливо, один розробник виконує весь інтерфейс, а інші реалізують функціональність цього інтерфейсу.

У відповідній примітці, якщо ви знаєте, що кілька історій будуть торкатися одних і тих же файлів, ви можете просто уникати роботи над ними одночасно. Не втягуйте їх усіх в один спринт і не починайте працювати над ними, поки не буде зроблено один або кілька.

Іншим можливим підходом до уникнення пізнього та великого злиття є прапорці функції : ви захищаєте свої зміни за допомогою (в ідеалі динамічно) настроюваного прапора, який заважає активізувати їх раніше, ніж призначено.

Це дозволяє вам об'єднати свої зміни на початку в ту masterчи іншу галузь спільного розвитку, нічого не порушуючи. Потім інші розробники можуть об'єднати ці зміни назад у свої гілки функцій (або відповідно відновити їх гілки).

Як вже було зазначено в інших відповідях, це слід поєднувати з рішенням безперервної інтеграції.

Функційні прапори мають додаткові переваги (наприклад, вони спрощують тестування A / B). Дивіться цю статтю Мартіна Фаулера для отримання додаткової інформації.

Ми дотримуємось підходу окремої галузі розробки для кожної функції, а потім ми об'єднуємо гілки в галузь QA для тестування в середовищі інтеграційного тестування.

Після завершення тестування регресії та інтеграції ми легко переміщуємо функції, готові перейти, до гілки випуску.

Якщо все піде добре, ми з’єднуємо гілку випуску назад у головну гілку.

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

Інші відповіді дають велике розуміння найкращих практик для комітетів, і, просто дотримуючись тих, ви, ймовірно, зменшите переважну більшість питань, пов’язаних із об'єднанням. Більше злиття майже напевно є необхідністю, але для меншої команди ваш підхід «на людину», ймовірно, працює досить добре. Звичайно, не завадить (сильно) потрапляти в більш розтяжні практики, хоча!

Однак, схоже, ніхто не звертався до одного з ваших найбільш важливих питань - що робити, коли всі ви торкаєтесь одних і тих же областей коду. Тут корисно мати ведучого, який знайомий з кодовою базою і може розпізнавати залежності різних завдань. Якщо вони не визначають терміни виконання робіт і зобов’язань, ви, швидше за все, зіткнетеся з конфліктами та об'єднанням рядків за рядком. Організувати задачі \ терміни набагато складніше з більшою командою, але з невеликою командою можливо виявити ці конфліктні завдання. Тоді ведучий може навіть перенести всі пов'язані завдання на одного і того ж інженера, щоб уникнути конфлікту взагалі.