Как вы поддерживаете код разработки и производственный код? [закрыто]

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

Как вы, ребята, поддерживаете свой код разработки и производственный код?

Редактировать - Дополнительный вопрос. Следует ли ваша команда разработчиков протоколу «как можно скорее, и часто даже если он содержит код, содержит незначительные ошибки или неполный» или «зафиксировать»? Протокол "ТОЛЬКО совершенный код" при передаче кода в ветку РАЗРАБОТКА?

Обновление 2019:

В наши дни вопрос будет рассматриваться в контексте использования Git, и 10 лет использования этого распределенного рабочего процесса разработки (в основном через GitHub ) демонстрируют общие рекомендации:

• masterготова ли ветвь к развертыванию в рабочей среде в любое время: следующий выпуск с выбранным набором ветвей функций master.
• dev(или ветвь интеграции, или ' next') - это та, в которой ветвь функций, выбранная для следующего выпуска, тестируется вместе.
• maintenance(или hot-fix) ветвь - это ветка для текущей версии / исправлений ошибок, с возможными слияниями к devи илиmaster

Такой рабочий процесс (где вы не сливаются devс master, но где вы сливаете только функцию ветвь dev, а затем , если выбран, чтобы для masterтого, чтобы иметь возможность легко уронить имеют филиалы не готовы к следующему выпуску) реализуется в Git сам репо с gitworkflow (одно слово, показанное здесь ).
Смотрите больше на rocketraman/gitworkflow. История этого против разработки на основе магистралей отмечена в комментариях и обсуждениях этой статьи Адама Димитрука .

^{(источник: Gitworkflow : учебник для начинающих )}

Примечание: в этом распределенном рабочем процессе вы можете фиксировать в любое время и передавать в персональную ветку некоторые WIP (Work In Progress) без проблем: вы сможете реорганизовать (git rebase) ваши коммиты, прежде чем сделать их частью ветви функций.

Оригинальный ответ (октябрь 2008 г., 10+ лет назад)

Все зависит от последовательности вашего управления выпуском

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

• слишком сложный и все еще нуждается в уточнении
• не готов вовремя
• интересно, но не для этого следующего выпуска

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

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

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

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

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

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

Чтобы ответить на комментарий Вилле М.:

• имейте в виду, что ветка dev не означает «одна ветвь на разработчика» (что вызовет «безумие слияния», поскольку каждый разработчик должен будет объединить работу других, чтобы увидеть / получить свою работу), но одна ветка dev на разработку усилия.
• Когда эти усилия необходимо объединить обратно в транк (или любую другую «основную» или ветвь релиза, которую вы определяете), это работа разработчика, а не - повторяю, НЕ - менеджера SC (который не знает, как решить любое конфликтующее слияние). Руководитель проекта может контролировать слияние, то есть убедиться, что оно начинается / заканчивается вовремя.
• кого бы вы ни выбрали для слияния, наиболее важным является:
  • иметь модульные тесты и / или среду сборки, в которой вы можете развернуть / протестировать результат слияния.
  • определить тег до начала слияния, чтобы иметь возможность вернуться к предыдущему состоянию, если указанное слияние оказывается слишком сложным или достаточно длинным для разрешения.

Мы используем:

• исключительно ветка развития

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

• ветвь релиза

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

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

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

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

На ранний заезд вопрос:

Если вам требуется только ИДЕАЛЬНЫЙ КОД для регистрации, то фактически ничего не должно быть зарегистрировано. Ни один код не идеален, и для проверки и тестирования его QA должен быть в ветке разработки, чтобы можно было построить новый исполняемый файл.

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

Время от времени неизбежная комбинированная проверка кода и данных делает программу непригодной для использования до тех пор, пока не будет создан новый код. Самое меньшее, что мы делаем, - это добавляем «WAIT FOR BUILD» в комментарии к регистрации и / или отправляем по электронной почте.

Для чего это стоит, вот как мы это делаем.

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

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

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

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

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

Почему никто до сих пор не упомянул об этом? Успешная модель ветвления Git .

Это для меня идеальная модель ветвления!

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

Разработка кода на ветках, Live код помечен на магистрали.

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

Вот более подробное пошаговое объяснение:

1. Делайте все разработки на ветке, регулярно совершая, как вы идете.
2. Независимый анализ кода изменений после завершения всех разработок.
3. Затем передайте ветку Тестированию.
4. Как только тестирование ветки завершено, объедините код с веткой Release Candidate.
5. Ветвь Release Candidate проверяется регрессионно после каждого отдельного слияния.
6. Окончательное тестирование QA и UA проводилось на RC после объединения всех ветвей разработки.
7. Как только QA и UAT пройдены, объедините ветку релиза с веткой MAIN / TRUNK.
8. Наконец, пометьте Trunk в этой точке и разверните этот тег в Live.

dev идет в транке (стиль svn), а релизы (рабочий код) получают свои собственные ветки

Это «Модель ветвления по назначению» (рисунок 3 в разделе « Важность моделей ветвления /! \ Pdf)»

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

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

Таким образом, нет никакой путаницы в том, какой код работает, это всегда основная ветвь.

О да - еще одна вещь - мы сохраняем непроизводственный код (то есть тот, который НИКОГДА не будет выпущен - например, скрипты инструментов, утилиты тестирования) в cvs HEAD. Обычно он должен быть четко обозначен, чтобы никто «случайно» не выпустил его.

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

Для транка единственным правилом является то, что коммит ничего не должен нарушать. Чтобы управлять wip-кодом и непроверенным кодом, мы просто добавляем соответствующие операторы if для упрощения включения и выключения.

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

Я использую git и у меня есть 2 ветки: master и maint

• мастер - код разработки
• maint - производственный код

когда я выпускаю код в производство, я помечаю его и объединяю master с maint branch. Я всегда развернут из ветки maint . Патчи из ветки разработки Я выбираю их из ветки maint и внедряю патчи.

У нас есть ветвь «релиз», которая содержит то, что в настоящее время находится в производстве или будет развернуто в ближайшее время (уже прошло большинство тестов)

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

Разработчики проекта вносят изменения в собственную ветку своего проекта. Периодически релиз сливается обратно в ветку разработки.

После того, как все рабочие пакеты в ветви будут QA'd (модульное тестирование, системный тест, проверка кода, проверка QA и т. Д.), Ветвь объединяется с веткой релиза. Новые сборки создаются из ветви выпуска, и окончательная проверка выполняется в этой версии.

Процесс в основном нормальный, пока проблема не будет обнаружена после слияния. Если WP «застревает» после слияния, он удерживает все после него, пока не будет исправлено (мы не можем сделать еще один выпуск, пока не выйдет зависший).

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

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

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