Когда фиксация контроля версий слишком велика? [закрыто]

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

Для меня, мне трудно пытаться делать «маленькие коммиты», так как я забываю или создаю что-то, что создает что-то еще, что создает что-то еще. Затем вы получите такие вещи:

Сделана настраиваемая исходящая очередь

Bot
-Новое поле msgQueue, которое является не чем иным, как SingleThreadExecutor
-sendMsg блокирует до отправки сообщения и добавляет ожидание между получением сообщений
послал
-adminExist вызовы обновлены (см. контроллер)
-Удаленные звонки, чтобы отправить сообщение

контроллер
-Новое поле msgWait обозначает время ожидания между сообщениями.
Запуск сервисных плагинов перенесен в reloadPlugins
-adminExists перенесены с сервера из-за глобальных администраторов. Проверяет на канале,
сервер и глобальный уровень

Администратор
-Новые методы getServer и getChannel, которые получают соответствующий объект Admin
принадлежит

BotEvent
-toString () также показывает extra и extra1

канал
поле переименовано в name
-Исправлена ​​опечатка в канале (int)

сервер
Перемещенный adminExists для контроллера

PluginExecutor
-Минор тестирование добавлено, будет удалено позже

JS плагины
-Обновлен к изменениям структуры
-Замененный InstanceTracker.getController () с Controller.instance
-VLC поговорим сейчас в собственном файле

Различные обновления и изменения проекта NB

---

Затронутые файлы
Изменить /trunk/Quackbot-Core/dist/Quackbot-Core.jar
Изменить /trunk/Quackbot-Core/dist/README.TXT
Изменить /trunk/Quackbot-Core/nbproject/private/private.properties
Изменить /trunk/Quackbot-Core/nbproject/private/private.xml
Изменить /trunk/Quackbot-Core/src/Quackbot/Bot.java
Изменить /trunk/Quackbot-Core/src/Quackbot/Controller.java
Изменить /trunk/Quackbot-Core/src/Quackbot/PluginExecutor.java
Изменить /trunk/Quackbot-Core/src/Quackbot/info/Admin.java
Изменить /trunk/Quackbot-Core/src/Quackbot/info/BotEvent.java
Изменить /trunk/Quackbot-Core/src/Quackbot/info/Channel.java
Изменить /trunk/Quackbot-Core/src/Quackbot/info/Server.java
Изменить /trunk/Quackbot-GUI/dist/Quackbot-GUI.jar
Изменить /trunk/Quackbot-GUI/dist/README.TXT
Изменить /trunk/Quackbot-GUI/dist/lib/Quackbot-Core.jar
Изменить /trunk/Quackbot-GUI/nbproject/private/private.properties
Изменить /trunk/Quackbot-GUI/nbproject/private/private.xml
Изменить /trunk/Quackbot-GUI/src/Quackbot/GUI.java
Изменить /trunk/Quackbot-GUI/src/Quackbot/log/ControlAppender.java
Удалить /trunk/Quackbot-GUI/src/Quackbot/log/WriteOutput.java
Изменить /trunk/Quackbot-Impl/dist/Quackbot-Impl.jar
Изменить /trunk/Quackbot-Impl/dist/README.TXT
Изменить /trunk/Quackbot-Impl/dist/lib/Quackbot-Core.jar
Изменить /trunk/Quackbot-Impl/dist/lib/Quackbot-GUI.jar
Изменить /trunk/Quackbot-Impl/dist/lib/Quackbot-Plugins.jar
Изменить /trunk/Quackbot-Impl/lib/javarebel.stats
Добавить /trunk/Quackbot-Impl/lib/jrebel.info
Изменить /trunk/Quackbot-Impl/nbproject/private/private.properties
Изменить /trunk/Quackbot-Impl/nbproject/private/private.xml
Изменить /trunk/Quackbot-Impl/nbproject/project.properties
Изменить /trunk/Quackbot-Impl/plugins/CMDs/Admin/reload.js
Добавить / trunk / Quackbot-Impl / плагины / CMDs / оператор / hostBan
Изменить /trunk/Quackbot-Impl/plugins/CMDs/Operator/mute.js
Изменить /trunk/Quackbot-Impl/plugins/CMDs/lyokofreak/curPlaying.js
Изменить /trunk/Quackbot-Impl/plugins/CMDs/lyokofreak/lfautomode.js
Изменить /trunk/Quackbot-Impl/plugins/listeners/onJoin.js
Изменить /trunk/Quackbot-Impl/plugins/listeners/onQuit.js
Изменить /trunk/Quackbot-Impl/plugins/testCase.js
Добавить /trunk/Quackbot-Impl/plugins/utils/whatsPlaying.js
Изменить /trunk/Quackbot-Impl/src/Quackbot/impl/SandBox.java
Добавить / trunk / Quackbot-Impl / vlc_http
Добавить /trunk/Quackbot-Impl/vlc_http/current.html
Изменить /trunk/Quackbot-Plugins/dist/Quackbot-Plugins.jar
Изменить /trunk/Quackbot-Plugins/dist/README.TXT
Изменить /trunk/Quackbot-Plugins/dist/lib/Quackbot-Core.jar
Изменить /trunk/Quackbot-Plugins/nbproject/private/private.properties
Изменить /trunk/Quackbot-Plugins/nbproject/private/private.xml
Изменить /trunk/Quackbot-Plugins/src/Quackbot/plugins/JSPlugin.java
Добавить / trunk / Quackbot-Plugins / vlc_http
Добавить /trunk/global-lib/jrebel.jar

Да ....

Итак, по вопросам:

• Каковы некоторые факторы, когда коммит становится слишком большим ( неочевидные вещи )?
• Как вы можете предотвратить такие коммиты? Пожалуйста, дайте конкретику
• А как насчет того, когда вы находитесь в полуранних стадиях развития, когда дела идут быстро? Огромные коммиты все еще в порядке?

Для меня, мне трудно пытаться делать «маленькие коммиты», так как я забываю или создаю что-то, что создает что-то еще, что создает что-то еще.

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

Проблема с большими коммитами:

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

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

(Другой случай, когда вы делаете первоначальный импорт, но это НЕ проблематично с точки зрения проблем, перечисленных выше.)

Принцип единой ответственности.

Каждый коммит контроля источника должен служить только одной цели. Если вам нужно вставить слово «и» или «также» в ваше резюме, вам нужно разделить его.

Очень часто в вашей рабочей копии происходит множество отдельных несвязанных или частично связанных изменений. Это называется «проблемой запутанной рабочей копии», и на самом деле ее очень трудно избежать даже дисциплинированным разработчикам. Тем не менее, Git и Mercurial предоставляют вам инструменты для ее решения - git add -p или chunk selection и Mercurial Queues в TortoiseHg соответственно.

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

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

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

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

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

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

В этом примере показан коммит, который слишком велик.

Как правило, опишите изменение одним предложением или одной строкой текста. (На основе этого правила коммит должен быть разбит на 10-15 меньших.) Если вы не можете адекватно комментировать коммит в одной строке, значит, он уже слишком большой.

Чтобы практиковать небольшие коммиты, делайте заметки в блокноте (или в блокноте) о том, что вы уже изменили или добавили. Зафиксируйте, прежде чем он станет длинным списком или перед тем, как вы внесете изменение кода, не связанное с тем, что у вас уже есть в блокноте.

В моей области (физическое моделирование) сегодня я обнаружил ошибку в выходных данных, которой не было в хранилище 6 месяцев назад. Когда это произойдет, я сделаю бинарный поиск по ревизиям:

1. Запустить модель от 3 месяцев назад
2. Если ошибка все еще выводится, запустите модель от 4,5 месяцев назад
3. ... повторяю, пока я не найду коммит, который дает плохой вывод

Когда ошибка была введена в чудовищном коммите, мне пришлось сесть с мелкозубчатым гребнем, чтобы найти источник проблемы. Если фиксация коснулась небольшого количества файлов, отследить строку (и) кода, который привел к проблеме, менее болезненно.

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

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

Например, вы можете изменить каждый экземпляр __macro1на __macro2большую кодовую базу, которая изменяет 200 файлов. 200 обязательств не были бы нормальными в этом случае.

То, что вы хотите получить, - это возможность извлекать хранилище в любой отдельной ревизии и выполнять сборку. Вы изменились с libfooна libbar? Я надеюсь, что это изменение включает в себя обновление ваших сборочных скриптов и Makefile-ов (или того, что применимо).

Иногда вам может потребоваться внести ряд экспериментальных изменений, которые выполняют одну задачу, и в этом случае вы должны определить, какая область более важна для вас, если вам придется вернуться позже. Зависит ли одно от другого? Передайте их все сразу в одной ревизии. В противном случае, в этом случае, я бы предложил один коммит на изменение. Вы должны делать что-то подобное в другой ветке или в любом случае в другом репо.

Хотя да, у вас есть возможность вернуть один файл к предыдущей ревизии (таким образом, сделав резервную копию одного файла из более крупного обязательства), сделав это, в дальнейшем, испортив инструменты, такие как деление пополам, и загрязнить историю.

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

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

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

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

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

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

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

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

По крайней мере, приучите себя к обязательству, когда вы думаете: «Мне нравится мой прогресс, и я не хочу его терять, если изменения, которые я собираюсь сделать, будут катастрофой». Затем у вас есть возможность воспользоваться VCS для устранения любых тупиков, которые вы пробовали, или специального кода отладки, который вы добавили, чтобы отследить проблему. (например, с помощью git reset --hardили rm -rf *; svn update)

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

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

Я имею в виду такие рекомендации:

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

Конечно - это то, что я имею в виду - YMMV. Разные разработчики предпочитают разные уровни детализации.

Чем меньше коммит, тем легче будет точно определить, откуда берется потенциальная регрессия.

В идеале коммит должен быть атомарным , в смысле наименьшего согласованного изменения в кодовой базе (связанной с ошибкой, функцией и т. Д.).

Что касается конкретных советов о том, как сохранить размер коммита небольшим, то он сильно зависит от вашей VCS и способа ее настройки: вы должны иметь возможность коммитить локально или работать в своей собственной ветке на сервере.

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

Используя dvcs, ваш рабочий процесс может выглядеть так:

code code code
git commit       // create commit locally with meaningful message
code code code
git commit       // create commit locally with meaningful message
code code code
git commit       // create commit locally with meaningful message
...
git push         // push your previous commits to the team server

Использование централизованного vcs:

svn copy trunk my_feature_branch  // create your private branch
svn co my_private_branch          //
code code code
svn commit                        // commit on your private branch with meaningful comment
code code code
svn commit                        // commit on your private branch with meaningful comment
code code code
svn commit                        // commit on your private branch with meaningful comment
...
svn merge my_feature_branch trunk  // all your previous commit are merged to main/master branch

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

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

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

Сообщения коммитов должны быть только одной строкой (и для git max 60 символов). Количество фиксируемого кода должно быть достаточно небольшим, чтобы описательное сообщение не выходило за эти пределы.

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

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

git citool Позволяет вам выбрать, какие конкретные фрагменты файла (или какие строки) следует зафиксировать в конкретном коммите, чтобы можно было разбить (не перекрывающиеся) изменения, внесенные в один и тот же файл, на несколько коммитов.

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

Чем больше коммит, тем больше вероятность, что вы сломаете сборку и получите деньги от остальной части вашей команды. Я пытаюсь совершать изменения два раза в день. Прямо перед обедом и прежде, чем я пойду домой. Итак, в 12:00 и 16:30 я пытаюсь заставить все работать и готово к принятию. Я считаю, что эта практика работает для меня.

Чтобы ответить на ваши вопросы:

1) Для меня стандартный коммит считается большим, если он делает больше, чем одну вещь. Под вещью я имею в виду исправление ошибки или добавление функции.

2) Предотвратите такие коммиты, сделав это привычкой и правилом коммитов, когда вы что-то заканчиваете.

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

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

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

Я также хотел бы отметить, что правила немного изменяются для распределенных систем контроля версий (DVCS), таких как Mercurial и Git. В случае, если вы используете один из них, вы фиксируете всякий раз, когда вносите изменения, но еще не тестировали его, а затем нажимаете на центральное хранилище, когда оно работает. Это предпочтительнее, поскольку позволяет пересматривать больше изменений в коде, не беспокоясь о нарушении сборки.

В моем случае я пытаюсь зафиксировать файлы сервера в системе хранилища (SVN). Это начальный коммит, и я не хочу его загружать, так как это действительно большой проект (несколько ГБ), и я хочу сделать первоначальный коммит с клиентского сервера.

Проблема заключается в том, что клиент находится на общем сервере, клиент SVN уничтожается (или любое другое программное обеспечение), если он работает более минуты.

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

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

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