как оставаться эффективным, когда сборка почти всегда нарушена

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

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

Сказав это, в течение дня у каждого есть несколько окон 10-15 минут, где мы разрешили зарегистрироваться.

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

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

Для начала, этот комментарий:

... наличие ветки подразумевает дополнительную сложность и, следовательно, дополнительную работу ...

полностью ложно. Я часто слышу это от людей, которые не привыкли к ветвлению, но это все равно неправильно.

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

Когда они наконец настаивают, это фактическое слияние .

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

Теперь вы говорите

никому не разрешено регистрироваться, пока строение красного цвета

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

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

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

В общем ответ на

как оставаться эффективным, когда сборка почти всегда нарушена

это: прекратить ломать сборку .

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

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

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

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

• ^{Примечание: каждый раз, когда менеджер делает или говорит что-то, что вынуждает вас избегать коммитов, хранить код локально, переводить их слова в смелый и простой текст «Я некомпетентен» .}

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

Ради точности, вы на самом деле можете , это вопросы влияния и коммуникативных навыков, и на самом деле не нужно быть во власти, чтобы изменить вещи по своему вкусу (поискать в Интернете что-то вроде «управлять») если вы Заинтересованы в более подробной информации).

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

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

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

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

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

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

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

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

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

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

Это оказалось успешным, потому что тесты сборки и проверки обычно занимали ~ 4 часа, поэтому нарушение сборки означало, что вы теряете половину дня при выполнении реальной работы. Излишне говорить, что это привело к тому, что разработчики более эффективно использовали ветви перед их объединением в магистраль. Для большинства разработчиков предыдущее мышление было «я просто позволю системе сборки CI уведомить меня, если мой код будет поврежден».

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

Здесь могут помочь еще две вещи:

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

Но вы действительно должны смотреть на ветви.