Ви продовжуєте розвиток у галузі чи в стовбурі? [зачинено]

Припустимо, ви розробляєте програмний продукт, який має періодичні випуски. Які найкращі практики щодо розгалуження та об'єднання? Вирізання гілок з періодичним випуском для загального користування (або того, хто є вашим клієнтом), а потім продовження розробки на магістралі або розглядаючи магістраль стабільною версією, періодичне позначення її як випуску та періодично виконувати експериментальну роботу. Як думають люди, чи вважають стовбур «золотим» чи «пісочним ящиком»?

Я спробував обидва способи з великим комерційним застосуванням.

Відповідь, який метод краще, сильно залежить від вашої точної ситуації, але я напишу те, що показав мій загальний досвід поки що.

Кращий метод в цілому (на мій досвід): Багажник повинен бути завжди стабільним.

Ось кілька рекомендацій та переваг цього методу:

• Зашифруйте кожне завдання (або пов'язаний набір завдань) у своїй власній галузі, тоді ви будете мати гнучкість, коли ви хочете об'єднати ці завдання та виконати випуск.
• Якість слід робити на кожній гілці до того, як вона злиється зі стовбуром.
• Роблячи QA на кожній окремій гілці, ви точно будете знати, що спричинило помилку.
• Це рішення важить будь-яку кількість розробників.
• Цей метод працює, оскільки розгалуження є майже миттєвою операцією в SVN.
• Тег до кожного випуску, який ви виконуєте.
• Ви можете розробити функції, які ви не плануєте випускати деякий час і вирішити, коли саме їх об’єднати.
• Для всієї роботи, яку ви виконуєте, ви можете скористатись кодом, скориставшись кодом. Якщо ви працюєте лише з магістралі, ви, ймовірно, будете тримати код не видаленим, а значить, незахищеним та без автоматичної історії.

Якщо ви спробуєте зробити все навпаки і зробити весь свій розвиток в багажнику, у вас виникнуть такі проблеми:

• Постійні проблеми у побудові щоденних побудов
• Втрата продуктивності, коли розробник розробляє проблему для всіх інших людей проекту
• Більше циклів випуску, тому що вам потрібно нарешті отримати стабільну версію
• Менш стабільні випуски

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

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

До речі, розподілені системи управління версіями забезпечують набагато більшу гнучкість, і я дуже рекомендую перейти на hg або git.

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

Люди вище, хто заперечує, кажучи, що у вас буде:

• Постійні проблеми у побудові щоденних побудов
• Втрата продуктивності, коли розробник розробляє проблему для всіх інших людей проекту

напевно, не використовували методи безперервної інтеграції.

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

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

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

Прочитайте статті Мартіна Фаулера про постійну інтеграцію . Ми розгорнули власну таку систему для великого проекту (3 000 кСЛОК) приблизно в 2000 ліній Posix sh.

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

Я розумію, що є й інші способи - це саме такий, як я це робив у минулому.

І те й інше.

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

Випуски підтримуються у власному каталозі, на них робляться лише виправлення помилок (а потім об'єднуються у магістраль).

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

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

Мені це подобається тому що:

• Це просто: ви можете отримати це з картинки.
• Він добре працює (і масштабує) без зайвих проблем з злиттям та конфліктами.
• Ви можете випустити "робоче програмне забезпечення" в будь-який час (в дусі спритного).

І на випадок, якщо це було недостатньо явно: розробка робиться в "робочих гілках", магістраль використовується для DONE (звільний) код. Перевірте контроль версій для кількох спритних команд на всі деталі.

Хорошим посиланням на процес розробки, який зберігає ствол стабільним і виконує всю роботу у галузях, - це кінцева система розвитку якості Divmod . Швидкий підсумок:

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

Для цього вони використовують SVN, але це легко зробити з будь-якою з розподілених систем управління версіями.

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

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

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

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

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

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

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

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

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

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

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

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

Деякі гілки знаходяться на стадії розробки настільки довго, що вам доведеться дозволити злиття від стовбура до гілки, щоб зменшити кількість сюрпризів, коли остаточно зливаються назад до стовбура.

Вам доведеться експериментувати, якщо у вас є велика група розробників і відчуєте, що працює у вашій ситуації. Ось сторінка від Microsoft, яка може бути дещо корисною: http://msdn.microsoft.com/en-us/library/aa730834(VS.80).aspx

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

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

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

Ми слідуємо магістралі = поточний потік розвитку, підрозділ = випуск (и). Після виходу до замовника ми розгалужуємо багажник і просто тримаємо багажник котитися вперед. Вам потрібно буде прийняти рішення про те, скільки випусків ви готові підтримати. Чим більше ви підтримуєте, тим більше злиття ви будете робити на виправлення помилок. Ми намагаємось утримувати своїх клієнтів не більше ніж 2 випуски позаду багажника. (Наприклад, Dev = 1,3, підтримувані версії 1.2 та 1.1).

Багажник, як правило, є основною лінією розвитку.

Випуски розгалужуються і часто проводяться експериментальні чи основні роботи на гілках, а потім зливаються назад до стовбура, коли вони готові інтегруватися з основною лінією розвитку.

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

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

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

Під CVS я би просто працював у "багажнику" і ніколи не тег / гілку, бо це було дійсно боляче робити інакше.

У SVN я би робив свої "кровоточачі" речі в багажнику, але коли настав час зробити серверне натискання, позначити належним чином.

Я нещодавно перейшов на git. Тепер я виявляю, що ніколи не працюю в багажнику. Натомість я використовую названу гілку пісочниці "new-featurename", а потім зливаюсь у фіксовану гілку "current-production". Тепер, коли я замислююсь над цим, я дійсно повинен робити гілки "VERSIONNUMBER", перш ніж об'єднатись у "поточне виробництво", щоб я міг повернутися до старих стабільних версій ...

Це дійсно залежить від того, наскільки добре ваша організація / команда управляє версіями та яким SCM ви використовуєте.

• Якщо те, що далі (у наступному випуску) можна легко спланувати, вам краще розробитись у магістралі. Управління філіями вимагає більше часу та ресурсів. Але якщо наступне неможливо легко спланувати (трапляється постійно у більших організаціях), ви, ймовірно, в кінцевому підсумку збираєте вишні (сотні / тисячі), а не гілки (кілька чи десятки).
• За допомогою Git або Mercurial керувати гілками набагато простіше, ніж резюме та підрив. Я б пішов за методологію стабільного ствола / теми. Це те, чим користується команда git.git. читати: http://www.kernel.org/pub/software/scm/git/docs/gitworkflows.html
• За допомогою Subversion я вперше застосував методику розробки в магістралі. Коли було відомо про дату випуску, було дуже багато роботи, оскільки щоразу мені доводилося вибирати вишні (моя компанія не дуже добре планує). Зараз я є своєрідним знавцем Subversion і досить добре знаю, як керувати гілками в Subversion, тому я рухаюсь до методології стійких стволів / тем. Це працює набагато краще, ніж раніше. Зараз я намагаюся працювати, як працює команда git.git, хоча ми, мабуть, будемо дотримуватися Subversion.

Ось SVN-дизайн, який я віддаю перевагу:

• корінь
  • розвиток
    • гілки
      • особливість1
      • особливість2
      • ...
    • стовбур
  • бета-версія
    • теги
    • стовбур
  • звільнення
    • теги
    • стовбур

Вся робота виконується з розробки / магістралі, за винятком основних функцій, які потребують власної гілки. Після того, як робота перевірена на розробку / магістраль, ми об’єднуємо перевірені проблеми в бета / магістраль. При необхідності код перевіряється на бета-сервері. Коли ми готові виконати деякі зміни, ми просто об'єднаємо відповідні зміни у випуск / магістраль та розгортаємось.

Теги можуть бути зроблені в бета-гілці або гілці випуску, щоб ми могли відслідковувати конкретний випуск як для бета-версії, так і для випуску.

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

Метод, який ми використовуємо, - це підхід Перфорса, який детально обговорюється у великій книзі Лори Вінгерд:

http://oreilly.com/catalog/9780596101855/index.html

Хоча книга орієнтована на перфорси (Wingerd - менеджер продуктів Perforce), ці концепції можуть бути застосовані до будь-якого або всіх VCS.

Підхід до виконання (і платформа) нам дуже добре послужив. Він використовується в багатьох компаніях (google, Intuit, і, я вже чув, сам Microsoft Windows).

Книгу варто прочитати.

Прочитайте це: http://oreilly.com/catalog/practicalperforce/chapter/ch07.pdf

На питання IMHO про конвенцію про підрив не існує жодної відповіді на один розмір.

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

Також - на мій досвід, з чистого адміністративного погляду, надзвичайно просто перемикатися між методами svn, коли ви вирішите.

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

@Brian R. Bondy: Зауважте, що це не рішення, коли ваша команда досягне певної кількості ppl / завдань, які паралельно обробляються у проекті.

Після того, як відділ контролю якості бере участь у питаннях q, зусилля, необхідні для забезпечення однієї установки на кожну галузь, що виконується, просто занадто великі. Подумайте, SOA / Клієнти / Сервери / Веб-сервіси / Бази даних, всі з яких мають бути надані в одній галузі .

Такого рішення також не вистачає на етапі інтеграції.