Когда пересмотреть код? До или после регистрации на ГЛАВНУЮ?
Просматривая stackru, я заметил несколько постов, в которых говорится, что некоторые разработчики рекомендуют пересмотреть код перед тем, как вернуться в MAIN. Однако может ли это быть действительно осуществлено? И если да, то, несомненно, это снижает вероятность того, что код будет подвергнут рефакторингу из-за увеличения накладных расходов?
Лично я предпочитаю подход с использованием непрерывной интеграции, чтобы поймать любого, кто нарушает сборку, а затем выполнить анализ кода на более грубой основе в конце значительной части работы. Я не требую проверки кода для незначительных рефакторингов.
Мне интересно услышать ваше мнение.
16 ответов
Все зависит от того, как настроена ваша организация.
Для небольших команд стратегия, которую я бы отстаивал, состоит в том, что все чекины должны быть непосредственно к вашему сундуку, различия должны отправляться в команду, и что все чекины должны проверяться командой из этих различий. Это имеет небольшие накладные расходы и стимулирует множество небольших проверок (которые легче просмотреть по электронной почте). В зависимости от вашей группы, вероятно, будет целесообразно сменить ответственного за проверку кода в любой момент времени. Затем вы проводите тестирование выпусков за пределами магистрали, отправляете их через QA, а затем выпускаете в производство после того, как QA одобрило их.
Большие команды, вероятно, занимаются разработкой в нескольких отраслях. В зависимости от того, как вы организованы, у вас есть возможности для проверки кода перед регистрацией (работает с парным программированием), перед слиянием (фактически, сколько работает проектов с открытым исходным кодом) или в регулярно запланированных точках в вашем цикле разработки (это будет более официальные отзывы).
Ключевое отличие здесь заключается в том, что маленькие команды занимаются сокращением процессов, а большие - контролем над коммуникациями. Но не отклоняйте динамику маленькой команды как непрофессионализм. Маленькие команды пользуются огромными преимуществами по сравнению с большими. Лоуренс Патнэм провел несколько увлекательных исследований по этому вопросу, которые вы можете найти в статье "Оценка программного обеспечения: демистификация черного искусства " Стива Макконнелла (см. Стр. 229). Он обнаружил, что для проектов среднего размера (~50000 строк кода) средняя команда из 5-7 человек выполнит за меньшее календарное время, чем средняя команда размером 15-20. Могу поспорить, что у небольшой команды есть более последовательный код, поэтому они, вероятно, достигли большего.
Помните, что это средние команды. Обратите внимание, что найти 5 исключительных людей легче, чем найти 20 из них. Поэтому проще создавать исключительно маленькие команды, чем исключительно большие. Учитывая задокументированные индивидуальные различия в производительности, я бы поспорил на серьезные деньги, что исключительная команда из 5 человек легко будет иметь более высокую пропускную способность, чем средняя команда из 100 человек. И их время выполнения на небольших проектах будет намного быстрее. Даже если вы платите им в четыре раза больше на человека, это все равно 1/5 от стоимости!
На мой взгляд, вы должны проверять код каждый раз, когда регистрируетесь. Стоимость исправлений возрастает, когда она в дереве.
- Делайте всю разработку на ветке, фиксируя ветку по мере продвижения.
- Код Проверьте изменения после завершения всех разработок.
- Затем передайте ветку Тестированию.
- Как только тестирование ветки завершено, объедините код с веткой Release Candidate.
- Ветвь Кандидата-релиза подвергается регрессионному тестированию после каждого отдельного слияния.
- Окончательное тестирование QA и UA проводилось на RC после объединения всех ветвей разработки.
- Как только QA и UA T пройдены, объедините ветку релиза с веткой MAIN/TRUNK.
В настоящее время мы выполняем Code Review вручную, но я настаиваю на установке Atlassian Crucible+FishEye, которая значительно облегчит процесс.
Парное программирование может быть полезно, когда у вас есть два человека с разными взглядами, работающими над определенной проблемой. Или научить одного разработчика незнакомому коду, но другой хорошо знает.
Тем не менее, для общего развития это может быть очень много времени и тратить ресурсы, которые могут работать на две разные вещи.
Многие из упомянутых политик проверки кода уже являются хорошими практиками в правильном контексте.
- Для основной функции, есть ветвь, в которой вы работаете, для всех проверок функций. Когда функция будет готова к включению, просмотрите объединенные изменения. Ветви объектов должны регулярно объединяться с основной, чтобы ветка не сильно расходилась и не дублировала обзор.
- Для проверок, идущих непосредственно в main, обзор кода для проверки обычно подходит. Каждый перерыв в сборке main оказывает большое влияние на всех разработчиков, работающих с main.
- В течение последней недели перед выпуском продукта, когда планка для принятия дефекта высока, не только должны быть рассмотрены все изменения, но они должны быть рассмотрены только назначенными старшими разработчиками, чтобы еще больше снизить риск изменения.
В моей нынешней компании мы иногда разрешаем проверки после проверки, если (а) податель является старшим разработчиком и (б) ожидание проверки существенно повлияет на других. Например, кто-то делает исправление в 10 вечера. Ожидание до утра перед выполнением проверки может повлиять на других разработчиков, а также на автоматические тесты и сам QA. Мы вводим дефект / элемент задачи другому разработчику, чтобы они сделали обзор. Таким образом, обзор не забывается.
Это зависит от того, какую политику управления исходным кодом и политику программного обеспечения вы используете. Если разработчик может зарегистрировать код, который он хочет сохранить, но не является конечным продуктом, то у вас ситуация, отличная от той, в которой каждая проверка приводит к созданию сборки с печатью и, возможно, отправкой в производство, чтобы исходный контроль был очень плотно заперты. Существуют ли множественные проверки, где что-то вроде Subversion или GIT по сравнению с чем-то вроде Sourcesafe, которые могут предотвратить несколько проверок.
Еще один момент в этом заключается в том, что подразумевается под обзором: этот кто-то просматривает чужой код, или это кто-то показывает остальной части команды: "Вот как я реализовал функцию ABC" или просто приводит? Это значительно варьируется и в некоторой степени связано с точкой контроля источника с точки зрения того, какая у вас рабочая среда с точки зрения того, как все организовано и структурировано.
Получить код зарегистрирован как можно скорее и как можно чаще. Чем раньше будет выполнен анализ кода, тем лучше время его изменения. Не позволяйте контролю качества и снижению производительности процесса. Обзор кода был сделан для разработчика, а не разработчика для обзора кода...
Я голосую за раньше. Неудача быстрее = неудача дешевле.
Проблема с ожиданием, пока вы не сломаете вещи, чтобы исправить их, заключается в том, что это работает только для небольших команд. Если у вас большие команды, то вероятность того, что кто-то что-то сломает в любой конкретный день, возрастет (рассмотрим команду из 100, все, что для этого нужно, - это частота дефектов, нарушающих сборку, равная 0,5 на каждого разработчика в год, в среднем, чтобы сборка была нарушена., КАЖДУЮ НЕДЕЛЮ).
Кроме того, с точки зрения поддержания высокого качества кода, лучшее время для улучшения качества кода - это когда он наиболее податлив, то есть до того, как он будет зарегистрирован.
Это, вероятно, зависит от типа обзора. Если вы говорите об официальной проверке, которая может занять часы / дни планирования и настройки, я бы сказал, что регистрация в порядке. Если в вашем магазине используются более неформальные обзоры / ходатайства, сделайте их как можно более безболезненными и убедитесь, что весь код проверен перед проверкой.
Если ваши обзоры связаны с "повышенными издержками", то вы правы, возможно, вы не захотите проводить проверку перед проверкой. Если ваш отзыв более неформальный, я бы выступил за применение политики проверки перед проверкой.
Мы проводим еженедельное обеденное собрание, чтобы проверить код, который мы написали на прошлой неделе. Обычно мы стараемся проверять код, измененный как часть итерации, до ее завершения. Таким образом, у разработчика есть несколько дней, чтобы внести рекомендуемые изменения, прежде чем будет предоставлена окончательная функциональность.
Мы обнаружили, что поскольку мы регулярно пересматриваем руководящие принципы (раз в неделю), изменения, которые необходимо внести, являются небольшими и могут быть реализованы довольно быстро.
ДОПОЛНЕНИЕ: Мы используем FxCop для автоматической проверки кода при каждой сборке. Таким образом, наши обзоры более мягки в отношении подхода, использования фреймворка, структуры и т. Д.
Обзоры кода не очень хороший способ предотвратить разрывы сборки. Одношаговый процесс сборки, одинаковый для всех наборов (как для разработчиков, так и для сборочных машин), должен предотвратить большинство разрывов сборки. Регулярное тестирование (как автоматическое, так и ручное) является лучшим способом выявления большинства ошибок.
Обзоры кода полезны, потому что:
1) Они гарантируют, что каждая строка кода была замечена по крайней мере двумя парами глаз в случае, если первая пара уходит в отпуск или покидает команду.
2) Они облегчают обмен идеями между рецензентом и рецензентом кода.
3) Они обеспечивают дополнительный уровень ответственности.
Поиск ошибок во время проверки кода (не говоря уже о перерывах в сборке) - приятный бонус, но не все, что часто встречается в моем опыте.
Преимущество проверки кода перед регистрацией состоит в том, что вы не распространяете дефекты кода (или разрывы сборки) среди остальной команды. Гораздо дешевле (для команды в целом) обнаружить как можно больше проблем перед регистрацией. Чем больше команда, тем более выражен этот эффект.
Парное программирование не всегда возможно и не желательно; людям нужно время, чтобы думать и работать непрерывно. Кроме того, проверка каждого коммита вместо больших наборов изменений приводит к огромным коммитам, с которыми трудно разобраться и понять (меньше коммитов == меньше рецензий == разработчики тратят меньше времени на собраниях).
Вы хотите, чтобы разработчики часто делали коммиты. Нередко настаивать на том, что коммиты не нарушают сборку, но вам нужно много небольших логических последовательностей коммитов как разработчиков функций. Здесь может помочь распределенная система контроля версий.
В небольшой команде с четким стажем я нашел, что тратить 30 минут в день на чтение различий из системы контроля версий довольно эффективно. Это описано здесь, в моем блоге.
В противном случае вам понадобится некоторая поддержка инструмента (например, Crucible). Планировать встречи и просматривать вещи на проекторе слишком больно; ты перестанешь это делать
Я думаю, что лучший способ избавиться от накладных расходов на проверку кода перед каждой проверкой - заставить разработчиков работать в парном программировании. Кроме того, вы можете назначить члена команды официальным рецензентом модуля X для конкретного проекта. И этот парень может делать более глубокие обзоры ежедневно.
Проверка кода при каждой регистрации уменьшит количество проверок и изменит размер регистрации. Такая большая регистрация увеличит риск разрыва.
Проверка кода не может предотвратить перерыв. Если один человек думает, что код в порядке, то другой может также думать, что это очень быстро. Непрерывная интеграция с высоким охватом кода лучше. Написание контрольного примера для большинства проверок имеет больше смысла.
Каждый раз, когда вы завершаете функцию (не забудьте запланировать время для нее как одну из задач функции!).
Проверка кода Каждая регистрация очень плохая - я хочу регистрироваться каждый час или даже больше, это невозможно при постоянных проверках кода. Кроме того, в этом нет необходимости - ваша главная задача при регистрации - убедиться, что вы не нарушаете существующий код, и в 90% случаев вам не нужен CR для этого.
При работе с существующим кодом, в котором вы не владеете свободно, вы можете пригласить людей для быстрого 3-минутного обзора деликатных фрагментов перед проверкой - это особенно важно в проектах с менее чем оптимальным охватом кода тестами (в таком проекте, даже если все модульные / интеграционные тесты пройдены, вы все равно не знаете, хорош ли ваш код).
Еще одна вещь, чтобы рассмотреть парное программирование. Это дает вам еще более немедленную обратную связь, вы просматриваете код по мере его написания. Это один из его самых больших плюсов.
Конечно, если вы не хотите этого делать, я бы рекомендовал вам не проверять политику возврата. Если ваши парни настолько плохи, что вы чувствуете, что должны, может потребоваться некоторая коррекционная подготовка.
Я склонен пересматривать время от времени во время простоя и когда я возвращаюсь к коду, чтобы исправить / изменить вещи.
Если вы настроите контроль версий для отправки различий всем разработчикам, есть шанс, что они сделают "незначительные обзоры" полуавтоматически.
Лично я предпочитаю подход с использованием непрерывной интеграции, чтобы поймать любого, кто нарушает сборку, а затем выполнить анализ кода на более грубой основе в конце значительной части работы. Я не требую проверки кода для незначительных рефакторингов.
Мои чувства такие же. Для меня проверка кода - это проверка качества и опыт изучения некоторой единицы кода, а не постепенных изменений. Обучение с другой стороны так же важно, как и другие преимущества анализа кода; любой обзор, который я сделал, я узнал.