Как часто передать изменения в управлении исходным кодом? [закрытый]
Исключение нулевого указателя - это индикатор того, что вы используете объект, не инициализируя его.
Например, ниже - класс ученика, который будет использовать его в нашем коде.
public class Student {
private int id;
public int getId() {
return this.id;
}
public setId(int newId) {
this.id = newId;
}
}
Приведенный ниже код дает вам исключение с нулевым указателем.
public class School {
Student obj_Student;
public School() {
try {
obj_Student.getId();
}
catch(Exception e) {
System.out.println("Null Pointer ");
}
}
}
Поскольку вы используете Obj_Student, но вы забыли инициализировать его, как в правильном коде, показанном ниже:
public class School {
Student obj_Student;
public School() {
try {
obj_Student = new Student();
obj_Student.setId(12);
obj_Student.getId();
}
catch(Exception e) {
System.out.println("Null Pointer ");
}
}
}
23 ответа
Каждый раз, когда я завершаю "полную мысль" о коде, который компилирует и выполняет I регистраций. Это обычно заканчивает тем, что было где угодно между 15-60 минутами. Иногда это могло быть более длинно, но я всегда пробую к регистрации, если бы у меня есть много изменений кода, которые я не хотел бы переписывать в случае отказа. Я также обычно удостоверяюсь свои компиляции кода и я регистрация в конце рабочего дня, прежде чем я пойду домой.
я не взволновал бы по поводу создания "слишком многих" фиксации/регистрации. Это действительно сосет, когда необходимо переписать что-то, и хорошо быть в состоянии откатывать в маленьких инкрементах на всякий случай.
Я все еще часто верю во фразе 'фиксации, фиксирую рано'. Я предпочитаю децентрализованный VCS как Подвижный и нет никакой проблемы фиксировать несколько вещей и продвинуть его в восходящем направлении позже.
Это - действительно общий вопрос, но реальный вопрос: можно ли фиксировать незаконченный код?
Если Вы работаете над ответвлением, которое не будет выпущено, фиксация всегда безопасна.
Однако, если Вы совместно используете его с другими разработчиками, фиксируя нерабочий код, вероятно, будет немного раздражающим (особенно, если это будет в важном месте). Обычно я только фиксирую код, который эффективно "работает" - не, что он был полностью протестирован, но что я установил, что он на самом деле компилирует и сразу не перестал работать.
при использовании интегрированного средства отслеживания ошибки может быть полезно сделать отдельные фиксации, если Вы исправили две ошибки, так, чтобы журнал фиксации мог идти вразрез с правильными ошибками. Но с другой стороны, иногда одно изменение кода исправляет две ошибки, таким образом просто необходимо выбрать, какой поместить его против (если система не позволяет одной фиксации быть связанной с несколькими ошибками)
Необходимо сбалансировать компромисс между безопасностью и восстанавливаемостью, с одной стороны, и простотой управления изменениями для всего проекта на другом.
лучшая схема, которую я использовал, имела два ответа на тот вопрос.
Мы использовали 2 абсолютно отдельных репозитория: каждый был широким репозиторием проекта, и другой был наш собственный персональный репозиторий (мы использовали rcs в то время).
Мы зарегистрировались бы в нашем персональном репозитории очень регулярно, в значительной степени каждый раз, когда Вы сохранили свои открытые файлы. Как таковой персональный репозиторий был в основном большим, долгим расположением, буфером отмены.
, Как только у нас был блок кода, который скомпилирует, протестированный хорошо и был принят как являющийся готовым к общему использованию, это было проверено в репозиторий проекта.
, К сожалению, эта система полагалась на использование различных технологий VCS, чтобы быть осуществимой. Я не нашел удовлетворительного метода достижения тех же результатов при использовании двух из VCS того же типа (например, два репозитория подрывной деятельности)
Однако, у меня были приемлемые результаты путем создания "персональных" ответвлений разработки в репозитории подрывной деятельности - зарегистрироваться в ответвлении регулярно и затем слияние в соединительную линию после завершения.
У меня нет определенного ограничения по времени на фиксацию, я склонен фиксировать, как только тест передал, и я доволен кодом. Я wouldn; t код фиксации, который не компилирует или находится иначе в состоянии, что я не чувствовал бы себя хорошо о возвращении к в случае отказа
Ну, у Вас могло быть свое собственное ответвление, которому можно фиксировать как часто как Вам угодно и когда Вы сделаны с Вашей функцией, Вы могли объединить его с основной соединительной линией.
На частоте Фиксаций, я думаю о нем этот путь, каким количеством боль была бы он быть мне, если мой жесткий диск отказал, и я не фиксировал что-то - квант этого, что-то для меня составляет приблизительно 2 часа работы.
, Конечно, я никогда не фиксирую что-то, что не компилирует.
Мне нравится фиксировать изменения каждые 30-60 минут, пока это компилирует чисто и в модульных тестах нет никаких регрессий.
Я соглашаюсь с несколькими из ответов: не регистрируйтесь в коде, который не скомпилирует; используйте персональное ответвление или репозиторий, если Ваше беспокойство имеет "резервное копирование" кода или его изменений; регистрация, когда логические единицы завершены.
Еще одна вещь, которую я добавил бы, состоит в том, что в зависимости от Вашей среды, уровень регистрации может меняться в зависимости от времени. Например, рано в проекте, регистрируясь после того, как каждая функциональная часть компонента завершена, имеет смысл и для безопасности и для наличия истории пересмотра (я думаю о случаях, где более ранние биты пересмотрены, поскольку более поздние разрабатываются). Позже в проекте, с другой стороны, совершенно полная функциональность становится более важной, особенно во время разработки/тестирования интеграции. Полуинтеграция или полуфиксирует, не помогает никому.
Что касается регистрации после каждого исправления ошибки: если фиксация не тривиальна, абсолютно! Ничто не больше боли, чем нахождение, что одна регистрация содержавших трех фиксирует, и один из них должен откатываться. Как правило, кажется, что в той ситуации разработчик исправил три ошибки в одной области и раскручивании, какое изменение идет, к которому исправление ошибки является кошмаром.
Момент Вы думаете об этом.
(как долго, поскольку то, в чем Вы регистрируетесь, безопасно)
Каждый раз, когда Вы заканчиваете некоторый код, который работает и не завинтит никого больше, если они получают его в обновлении.
И удостоверьтесь, что Вы комментируете правильно.
Ваш текущий шаблон имеет смысл. Следует иметь в виду как Вы использование это управление исходным кодом: что, если необходимо откатывать, или если Вы хотите сделать разность? Блоки, которые Вы описываете, походят точно на правильный дифференциал в тех случаях: разность покажет Вам точно, что изменило в реализации ошибки # (определенный в журнале регистрации), или точно чем новый код был для того, чтобы реализовать опцию. Откат, точно так же только коснется одной вещи за один раз.
Зависит от Вашей системы исходного кода и что еще Вы имеете в распоряжении. Если Вы используете Мерзавца, то фиксируете каждый раз, когда Вы заканчиваете шаг. Я использую SVN, и мне нравится фиксировать, когда я заканчиваю целую функцию, таким образом, все к пяти часам. Если бы я использовал CVS, то я сделал бы то же.
Я не думаю, что необходимо волноваться так о как часто. Важная вещь здесь что, когда и почему. Высказывание, что Вы должны фиксировать каждые 3 часа или каждые 24 часа действительно не имеете никакого смысла. Фиксация, когда у Вас есть что-то для фиксации, не делает, если Вы не делаете.
Вот извлечение из моего рекомендуемые лучшие практики для управления версиями :
[...], Если Вы делаете много изменений в проекте одновременно, разделяет их на логические части и фиксируют их на нескольких сессиях. Это делает намного легче отследить историю отдельных изменений, которые сохранят Вас много времени при попытке найти и исправить ошибки позже. Например, если Вы реализуете функцию A, B и C и исправляете ошибку 1, 2 и 3, который должен привести к в общей сложности по крайней мере шести фиксациям, один для каждой функции и один для каждой ошибки. Если Вы работаете над большой функцией или делаете обширный рефакторинг, рассматриваете разделение Вашей работы в еще меньшие части и делаете фиксацию после того, как каждая часть будет завершена. Кроме того, при реализации независимых изменений в нескольких логических модулях передайте изменения в каждом модуле отдельно, даже если они - часть большего изменения.
Идеально, Вы никогда не должны оставлять свой пост с незафиксированными изменениями на Вашем жестком диске. Если Вы работаете над проектами, где изменения будут влиять на других людей, рассмотреть использование ответвления, чтобы реализовать Ваши изменения и объединить их назад в соединительную линию, когда Вы будете сделаны. Когда передача изменений в библиотеках или проектах, от которых другого projects— и таким образом, зависят другие people—, удостоверяется Вы, don’t повреждают свои сборки путем фиксации кода это компиляция won’t. Однако имея код, который компиляция doesn’t не является оправданием постараться не фиксировать. Используйте ответвления вместо этого. [...]
Эмпирическое правило, которое я использую, является регистрацией, когда группа зарегистрированных файлов может быть охвачена единственным комментарием регистрации.
Это должно обычно гарантировать, что регистрации являются атомарными и что комментарии могут быть легко переварены другими разработчиками.
Это особенно верно, когда Ваши изменения влияют на конфигурационный файл (такой как пружинный файл контекста или файл конфигурации распорок), который имеет приложение широкий объем. При создании нескольких 'групп' изменений, прежде чем регистрация, их влияние наложится в конфигурационном файле, заставляя эти 2 группы стать объединенным друг с другом.
Я следую, (перефразируемая) молитва с открытым исходным кодом - фиксируют рано, часто фиксируют.
В основном каждый раз, когда я думаю, что добавил полезную функциональность (однако маленький), не представляя проблемы для других членов команды.
Эта стратегия фиксации часто особенно полезна в непрерывных средах интеграции, поскольку она позволяет интеграционное тестирование против других усилий по разработке, давая раннее обнаружение проблем.
Не фиксируйте код, который на самом деле не работает. Не используйте свой репозиторий в качестве решения для резервного копирования.
Вместо этого создайте резервную копию своего неполного кода локально автоматизированным способом. Машина времени заботится обо мне, и существует много бесплатных программ для других платформ.
Я фиксирую каждый раз, я сделан с задачей. Это обычно занимает 30 минут к 1 часу
Если Вы вносите существенные изменения и обеспокоены влиянием на других, работающих над кодом, можно создать новое ответвление, и затем объединиться назад в соединительную линию после того, как изменения завершены.
Я лично фиксирую каждую логическую группу кода, который является заканчивать/стабильными/компиляциями, и попытайтесь не оставить день, не фиксируя то, что я сделал в тот день.
Мне нравится эта маленькая статья от Jeff Atwood: Регистрация Рано, Регистрация Часто
Когда Вы говорите, что обеспокоены, что Ваши "фиксации влияют на целый репозиторий",---Вы относятся к тому, что число пересмотра целого репозитория увеличивается? Я не знаю, сколько использования Подрывной деятельности битов для хранения его но я вполне уверен, Вы не собираетесь заканчиваться числа пересмотра! Много фиксаций не являются проблемой. можно фиксировать в десять раз более часто, чем парень по соседству, и Вы не увеличите свой углеродный след вообще.
А единственная функция или метод должны быть названы по имени того, что это делает, и если имя является слишком длинным, это делает слишком много. Я пытаюсь применить то же правило к регистрациям: комментарий регистрации должен описать точно, что изменение выполняет, и если комментарий является слишком длинным, я, вероятно, изменяюсь слишком много сразу.
Мне также нравится фиксировать после того, как я заканчиваю блок работы, которая является часто несколько раз в день. Я думаю, что легче видеть то, что происходит в маленьких фиксациях, чем большие. Если Вы волнуетесь по поводу слишком многих фиксаций, можно рассмотреть создание ответвления и слияние его назад к соединительной линии, когда целая функция закончена.
Вот связанное сообщение в блоге: Ужас Кодирования: Регистрация Рано, Регистрация Часто