Можете ли вы сделать непрерывное развертывание с младшими программистами?

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

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

Но возможно ли это сделать с младшими программистами? Возможно, мне придется реализовать схему pull-запроса. Это сделало бы его менее похожим на непрерывное развертывание (это мое предположение)?

Я надеюсь, что это не основано на мнении, и я могу рассчитывать на то, что вы поделитесь своим опытом, спасибо.

Обратите внимание, я не спрашиваю ни о КИ, ни о непрерывной доставке. У нас это уже есть. То, что мы сейчас пытаемся сделать, это сделать его непрерывным развертыванием, что означает, что все это будет запущено в производство сразу после регистрации кода.

Почему бы и нет? Любая из вещей, которые вы опишите, будет проблемой, используете ли вы непрерывное развертывание или нет. Проблема, кажется, в том, что вы беспокоитесь, что юниоры совершат катастрофическую ошибку. И эта ошибка будет срочно отправлена ​​в производство, прежде чем кто-нибудь сможет ее поймать.

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

Непрерывное развертывание будет хорошо работать, если у вас есть хороший набор автоматических тестов.

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

Они устранят небольшие проблемы по мере их возникновения и обеспечат непрерывную доставку.

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

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

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

Из прошлого опыта работы с кодовой базой Big Ball Of Mud, которая развивалась естественным образом на протяжении многих лет в руках многих неконтролируемых начинающих разработчиков, я хотел бы указать, что происходит, когда вы не практикуете CI с этими разработчиками.

Редактирование / обновление : согласно комментарию RubberDuck; в этом ответе предполагается, что целью объединения для интеграции является ветвь разработки, а не ветвь оценки или выпуска.

• Очевидно, что должен быть намного больший контроль над кодом для выпуска и оперативного развертывания; если нет отдельной производственной ветви, то стоит рассмотреть изменение вашей стратегии ветвления / слияния, чтобы запустить основную ветку разработки (которая используется для интеграционного тестирования, а не для выпуска) вместе с основной веткой выпуска. Это сохраняет все преимущества CI и частых слияний, не рискуя нарушить производственный код.

1. Младшие разработчики реже общаются со своими коллегами или руководителем

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

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

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

2. Код, который они создают, вероятно, нуждается в более тщательном рассмотрении.

Вы когда-нибудь просматривали что-то настолько плохое, что хотели, чтобы вы взяли его раньше и не писали? Это часто случается.

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

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

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

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

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

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

4. Вероятно, они менее знакомы с общими шаблонами, архитектурой существующего кода, а также с хорошо известными инструментами и решениями.

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

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

5. Длительные периоды между фиксацией / слиянием кода затрудняют выявление и устранение дефектов

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

Очевидно, что ваша общая стратегия ветвления также вступает в игру здесь; в идеале все ваши разработчики будут либо работать в своих собственных ветвях, либо в функциональных ветвях (или в обеих), и никогда не будут работать напрямую от master / trunk.

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

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

В итоге; Основными преимуществами непрерывной интеграции / непрерывного развертывания являются:

• Улучшается связь между вашей командой
• Качество кода обычно поддерживается на более высоком уровне
• Требования с меньшей вероятностью будут пропущены или неверно истолкованы
• Проблемы архитектуры и дизайна должны обнаруживаться быстрее,
• Дефекты с большей вероятностью будут обнаружены и устранены на более ранней стадии

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

Да, вы можете практиковать CI с младшими разработчиками. Было бы глупо не в нынешних условиях развития. Безумно полезно иметь возможность нажать на репо, а затем автоматически объединить его с промежуточным кодом - и смотреть все это в режиме реального времени в Travis (или Bamboo, Pipelines и т. Д.)!

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

Если вы обеспокоены тем, что код дерьма будет проходить, это не на CI и не на младших: это на вас .

Помогите им стать лучше и привыкли быстрее развертывать код stage / prod. Вы будете благодарить себя в долгосрочной перспективе.