Как Вы поддерживаете код разработки и производственный код? [закрытый]
В Java все находится в форме класса.
Если вы хотите использовать любой объект, тогда у вас есть две фазы:
- Объявить
- Инициализация
Пример:
- Объявление:
Object a; - Инициализация:
a=new Object();
То же самое для концепции массива
- Объявление:
Item i[]=new Item[5]; - Инициализация:
i[0]=new Item();
Если вы не дают секцию инициализации, тогда возникает NullpointerException.
11 ответов
Обновление 2019:
В эти дни, вопрос был бы замечен в контексте с помощью Мерзавца, и 10 лет использования, это распределило разработка , рабочий процесс (сотрудничающий главным образом через GitHub) показывает общие лучшие практики:
-
masterответвление, готовое быть развернутым в производство в любое время: следующий выпуск, с выбранным набором ответвлений функции, объединенных вmaster. -
dev(или ответвление интеграции, или'next') тот, где ответвление функции, выбранное для следующего выпуска, тестируется вместе -
maintenance(илиhot-fix), ответвление является тем для текущей эволюции/исправлений ошибок выпуска, с возможными слияниями назад кdevи илиmaster
Такой рабочий процесс (где Вы не объединяетесь dev с master, но где Вы объединяете только ответвление функции с [1 110], затем, если выбрано, с [1 111], чтобы смочь отбросить легко ответвления функции, не готовые к следующему выпуску), реализован в Мерзавце repo самому, с gitworkflow (одно слово, проиллюстрированный здесь ).
Посмотрите больше в [1 119] rocketraman/gitworkflow .
<глоток> (источник: Gitworkflow: Ориентированная на задачу Краткая информация )
Примечание: в том распределенном рабочем процессе можно фиксировать каждый раз, когда Вы хотите и продвигаете к персональному ответвлению некоторый WIP (Происходящая Работа) без проблемы: Вы сможете реорганизовать (перебаза мерзавцев) свои фиксации прежде, чем сделать их частью ответвления функции.
<час>Исходный ответ (октябрь 2008, 10 + несколько лет назад)
Все это зависит последовательная природа Вашего управления версиями
Первый, все в Вашей соединительной линии действительно для следующего выпуска ? Вы могли бы узнать, что некоторые в настоящее время разрабатываемые функции:
- слишком сложный и все еще должен быть усовершенствован
- не готовый вовремя
- интересный, но не для этого следующего выпуска
В этом случае, соединительная линия должна содержать любые текущие усилия по разработке, но ответвление выпуска определило рано, прежде чем следующий выпуск может служить ответвление консолидации , в котором только соответствующий код (проверил для следующего выпуска), объединяется, затем фиксируется во время фазы гомологизации и наконец замораживается, поскольку это входит в производство.
Когда дело доходит до производственного кода, также необходимо управлять Вашим ответвления патча при учете того факта что:
- первый набор патчей мог бы на самом деле начаться, прежде для первого выпуска в производство (значение Вас знают, Вы войдете в производство с некоторыми ошибками, которые Вы не можете исправить вовремя, но можно инициировать работу для тех ошибок в отдельном ответвлении)
- , другие ответвления патча будут иметь роскошь для запуска с четко определенного производства, маркируют
When it comes to dev ответвление, у Вас может быть одна соединительная линия, если у Вас нет других усилий по разработке, необходимо сделать в параллели как:
- крупный рефакторинг
- тестирование новой технической библиотеки, которая могла бы изменить способ, которым Вы называете вещи в других классах
- начало нового цикла выпуска, где важные изменения в архитектуре должны быть включены.
Теперь, если Ваш цикл выпуска разработки очень последователен, можно просто пойти, как другие ответы предполагают: одна соединительная линия и несколько ответвлений выпуска. Это работает на маленькие проекты, где вся разработка, несомненно, войдет в следующий выпуск, и может просто быть заморожена и служить начальной точкой для ответвления выпуска, где патчи могут произойти. Это - номинальный процесс, но как только у Вас есть более сложный проект... это недостаточно больше.
<час>Для ответа на Ville M. 's комментарий:
- имеют в виду, что ответвление dev не означает 'одно ответвление на разработчика' (который инициировал бы 'безумие слияния, в котором каждый разработчик должен будет объединить работу другого для видения/получения их работы), но одно ответвление dev на усилие по разработке.
- , Когда те усилия должны быть объединены назад в соединительную линию (или любое другое "основное" ответвление или ответвление выпуска Вы определяете), это - работа разработчика, не - я повторяюсь, НЕ - менеджер по SC (кто не знал бы, как решить любое конфликтующее слияние). Руководитель проекта может контролировать слияние, значение удостоверяются, что оно запускает/заканчивает вовремя.
- , для кого бы ни Вы выбираете для того, чтобы на самом деле сделать слияние, самое важное:
- , чтобы иметь модульные тесты и/или среду блока, в которой можно развертывать/тестировать результат слияния.
- для определения тега прежде начало слияния, чтобы смочь возвратиться к предыдущему состоянию, если упомянутое слияние оказывается слишком сложный или довольно длинный для разрешения.
Мы используем:
- ответвление разработки исключительно
до проекта приближается к завершению, или мы создаем эпохальную версию (например, демонстрация продукта, версия презентации), затем мы (регулярно) отклоняемся наше текущее ответвление разработки в:
- ответвление выпуска
Никакие новые возможности не входят в ответвление выпуска. Только важные ошибки исправлены в ответвлении выпуска, и код для исправления этих ошибок повторно интегрируется в ответвление разработки.
процесс с двумя частями с разработкой и конюшней (выпуск) ответвление делает жизнь намного легче для нас, и я не полагаю, что мы могли улучшить любую часть его путем представления большего количества ответвлений. Каждое ответвление также имеет свой собственный процесс сборки, означая каждую пару минуты, новый процесс сборки порожден и поэтому после регистрации кода, у нас есть новый исполняемый файл всех версий сборки и ответвлений приблизительно в течение получаса.
Occassionally у нас также есть ответвления для единственного разработчика, работающего над новой и недоказанной технологией или создающего подтверждение концепции. Но обычно это только сделано, если изменения влияют на многие части кодовой базы. Это происходит в среднем каждые 3-4 месяца, и такое ответвление обычно повторно интегрируется (или фрагментируется) в течение месяца или два.
Обычно мне не нравится идея каждого разработчика, работающего в его собственном ответвлении, потому что Вы "пропускаете, идут и перемещаются непосредственно в ад интеграции". Я категорически не рекомендовал бы его. Если у Вас есть общая кодовая база, необходимо все работать в ней вместе. Это делает разработчиков более осторожными об их checkins, и с опытом знает каждый кодер, какие изменения потенциально повреждают сборку, и таким образом тестирование более строго в таких случаях.
На регистрации ранний вопрос:
, Если Вы требуете, чтобы только [1 112] ИДЕАЛЬНЫЙ КОД были зарегистрированы, затем на самом деле, ни в чем нельзя зарегистрироваться. Никакой код не прекрасен, и чтобы QA проверил и протестировал его, это должно быть в ответвлении разработки, таким образом, новый исполняемый файл может быть создан.
Для нас, который означает, после того как функция завершена и протестирована разработчиком, в ней регистрируются. В этом можно даже зарегистрироваться, если бы там известны (нефатальные) ошибки, но в этом случае людям, которые были бы затронуты ошибкой, обычно сообщают. В неполном и происходящем работой коде можно также зарегистрироваться, но только если он не вызывает очевидных отрицательных эффектов, как катастрофические отказы или повреждение существующей функциональности.
Время от времени неизбежный объединенный код & регистрация данных сделает программу неприменимой, пока новый код не был создан. Очень наименьшее, которое мы делаем, должно добавить, "ОЖИДАЮТ СБОРКИ" в регистрации, комментируют и/или отсылают электронное письмо.
Если это имеет значение это - то, как мы делаем это.
Большая часть разработки выполняется в соединительной линии, хотя экспериментальные функции или вещи, которые могли бы повредить систему значительно, имеют тенденцию получать свое собственное ответвление. Это удается вполне прилично, поскольку это означает, что у каждого разработчика всегда есть последняя версия всего в их рабочей копии.
Это действительно означает, что важно удержать соединительную линию неопределенно рабочее состояние, поскольку совершенно возможно полностью повредить его. На практике это часто не происходит и редко является значительной проблемой.
Для производственного выпуска, мы переходим соединительная линия, прекращаем добавлять новые опции и работу над bugfixing и тестировать ответвление (регулярно объединяющийся назад в соединительную линию), пока это не готово к выпуску. В которой точке мы делаем заключительное слияние в соединительную линию, чтобы удостовериться, что все там, и затем выпустите.
Обслуживание может затем быть выполнено на ответвлении выпуска по мере необходимости, и те меры могут быть легко объединены назад в соединительную линию.
я не утверждаю этого быть идеальной системой (и она все еще имеет некоторые дыры - я не думаю, что наше управление версиями является достаточно трудным процессом все же), но она работает достаточно хорошо.
Код разработки ответвлений, Живой код наклеил Соединительную линию.
не должно быть "фиксации только идеальный код" правило - что-либо, что пропускает разработчик, должен быть взят в четырех местах: обзор кода, тестирование ветвей, регрессионное тестирование, заключительное тестирование QA.
Вот более подробное пошаговое объяснение:
- Делают всю разработку на ответвлении, фиксируя регулярно, когда Вы идете.
- Независимый Обзор Кода изменений, после того как вся разработка завершена.
- Затем передают ответвление к Тестированию.
- Однажды завершенное тестирование ветвей, объедините код в ответвление Предвыпускной версии.
- ответвление Предвыпускной версии является регрессией, протестированной после каждого отдельного слияния.
- Финал QA и Тестирование UA, выполненное на RC после всех ответвлений dev, объединенных в.
- , После того как QA и UAT передаются, ответвление выпуска слияния в ОСНОВНОЕ ответвление / МАГИСТРАЛЬНОЕ ответвление.
- Наконец, отметьте Соединительную линию в той точке и разверните тот тег для Проживания.
dev входит в соединительную линию (svn стиль), и выпуски (производственный код) получают свои собственные ответвления
, Это - "Ответвление - моделью цели" (рисунок 3 в важность моделей ветвящегося процесса /! \PDF)
Мы решаем эту проблему путем завершенного разделения производственного кода (основная соединительная линия) из кода разработки (где у каждого разработчика есть свое собственное ответвление).
Никакой код не позволяется в производственный код, прежде чем он был полностью проверен (QA и рецензентами кода).
Таким образом, там не является никакой беспорядок, о котором работает код, это всегда - основное ответвление.
Ах да - еще одна вещь - мы сохраняем непроизводственный код (т.е. то, что никогда не будет выпускаться - например, сценарии инструмента, тестируя утилиты) в ГОЛОВЕ cvs. Обычно это должно быть ясно отмечено так, никто "случайно" не выпускает его.
Мы разрабатываем на соединительной линии, которая затем переходится каждые две недели и вводится в эксплуатацию. Только критические ошибки исправлены в ответвлении, остальные могут ожидать еще две недели.
Для соединительной линии единственное правило состоит в том, что фиксация ничего не должна повреждать. Для управления wip-кодом и непротестированным кодом, мы просто добавляем соответствующий если statments, чтобы помочь включить и прочь.
В основном было бы возможно перейти соединительная линия в любое время и ввести его в эксплуатацию.
Я использую мерзавца, и у меня есть 2 ответвления: ведущее устройство и ведущее устройство maint
- - код разработки
- maint - производственный код
, когда я выпускаю код к производству, я отмечаю его, и я объединяюсь ведущее устройство к ответвление maint. Я всегда развертываюсь от ответвление maint. Патчи от разработки переходят, я избирательно подхожу к выбору их к ответвлению maint и развертываю патчи.
У нас есть ответвление "выпуска", которое содержит то, что в настоящее время находится на производстве или будет развернуто вскоре (уже передал большую часть QA)
, Каждый проект или в некоторых случаях другая единица, имеет свое собственное ответвление, которое переходится от выпуска.
Изменения фиксируются, разработчиками на проекте, в собственное ответвление их проекта. Периодически, выпуск объединяется назад в ответвление разработки.
, После того как пакеты работы на ответвлении являются всем QA'd (модульный тест, тестирование системы, кодируйте обзор, обзор QA и т.д.), ответвление объединяется в ответвление выпуска. Новая сборка (сборки) создается из ответвления выпуска, и заключительная проверка происходит на той версии.
процесс в основном в порядке, пока проблема не обнаружена после того, как слияние было сделано. Если WP вовлекает после того, как он был объединен, он держит все после него, пока он не зафиксировал (мы не можем сделать другого выпуска, пока застрявший не выпущен).
<час>Это также несколько гибко - очень тривиальное изменение могло произойти непосредственно на ответвлении выпуска, если бы это выпускалось в очень кратковременном масштабе (как приблизительно 1-2 дня).
, Если изменение было помещено непосредственно на производстве по некоторым причинам (критическая влияющая на клиента производственная проблема, которая потребовала, чтобы непосредственное изменение кода зафиксировало), те изменения будут отложены в BRANCH_RELEASE. Этого почти никогда не происходит.
Это зависит от проекта. В нашем веб-коде регистрируются довольно последовательно, в то время как в нашем коде приложения только регистрируются, если он компилирует. Я заметил, что это довольно подобно тому, как мы выпускаем вещи. Веб-материал повышается каждый раз, когда он может, в то время как приложения поражают трудный крайний срок. Я не видел потери качества ни в одном методе все же.