Методология управления предпочтительной версией

Ответ 1

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

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

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

В репозитории он выглядит примерно так:

• Магистральные

  • v1.0.1.x Release

  • v1.0.2.x Release

    • v1.0.2.x Bug-Fix A < - (они объединяются обратно в Trunk, но остаются на репо)
    • v1.0.2.x Bug-Fix B

  • v1.1.1.x Release

  • v1.2.1.x Development < - (Это будет объединено обратно к Trunk и заменено папкой Release)

    • v1.2.1.x Новая функция A < - (они объединяются обратно в ветку разработки)
    • v1.2.1.x Новая функция B

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

Удачи!

Ответ 2

Я делаю все свое развитие в багажнике. Я один разработчик и не хочу иметь дело с хлопотами разветвления. Когда мой код стабилен, я просто помечаю эту текущую версию. Например, я бы пометил версию 1.0, 2.0 beta, 2.0 release 1, версию 2.0 и т.д. Ветвление, вероятно, было бы лучшей альтернативой, если бы вы поддерживали старые версии исправлений и поддержки ошибок, но поскольку я этого не делаю, беспокоиться об этом.

Ответ 3

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

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

Ответ 4

Всегда стабильно. Даже если я один разработчик - особенно, если я одинокий разработчик.

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

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

Ответ 5

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

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

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

Если большой эксперимент работает, он снова объединяется в основной.

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

Ответ 6

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

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

Ответ 7

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

Ответ 8

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

Ответ 9

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

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

Ответ 10

Одним из аспектов является то, как долго изменения будут в неустойчивом состоянии.

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

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

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

Ответ 11

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

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

Если вы работаете с меньшими, очень сплоченными файлами, типичными для дизайна OO, на языке, подобном Java, такие случайные конфликты намного реже. Даже в качестве искусственного примера довольно сложно придумать два набора изменений, которые могут быть внесены в класс (и соответствующие тестовые примеры JUnit), которые можно разумно сделать изолированно, а затем автоматически сплести вместе с помощью инструмента слияния текста.

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

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

В первом подходе новые функции записываются в новые ветки и объединены при завершении. Во втором он записывается в новые файлы и включается при завершении.

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