Что мне делать, если я уже слишком долго ждал между коммитами?

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

Что лучше?

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

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

Кстати: я использую SVN и Subclipse. Я создал новую ветку, прежде чем делать какие-либо из этих изменений.

Дополнительная информация : я задал отдельный вопрос, связанный с тем, как я попал в эту ситуацию: как подготовиться к переписыванию клея приложения

Чтобы ответить, вы должны спросить себя, как вы собираетесь использовать результаты этих коммитов в будущем. Наиболее распространенные причины:

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

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

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

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

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

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

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

Вариант 1 запутывает историю изменений, которые вы сделали, но в противном случае это не вызовет никаких проблем.

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

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

На основании предоставленной вами информации я бы выбрал вариант 1. Может быть, вам следует настроить напоминания, предлагающие вам внести изменения?

Прототипирование и переписывание

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

При создании прототипа нового кода выполняйте коммит всякий раз, когда хотите сохранить изменения, почти наверняка в ветке, но, возможно, в отдельном проекте. Или, может быть, даже просто работать вне системы контроля версий. Вместо этого вы можете сосредоточиться на сборе доказательств о целесообразности различных гипотез или конструкций, которые вы рассматриваете. Я часто пишу небольшие прототипы, используя различные инструменты, например LINQPad вместо Visual Studio для кода C #.

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

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

Поэтому я бы выбрал вариант 1. Если это невозможно, то вариант 2.

Вариант 3 требует больших усилий, и это просто не стоит.

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

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

1. Добавьте только код, который относится к определенной функции: git add --patch
2. Копить все остальные изменения: git stash save --keep-index
3. Запустите тесты / попробуйте скомпилировать
4. Внесите изменения, если все в порядке, если не перейти к 1

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

Как насчет варианта 4: сделать резервную копию текущего состояния репо во временном месте, вернуть репо в исходное состояние, составить список всех изменений, которые вы сделали (вы все еще можете посмотреть временную резервную копию), затем вручную переопределить (и скомпилировать и проверить!) их как отдельные коммиты.

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

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

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

Вы вероятно откатите "части" того, что вы сделали? Если нет, то обязательно перейдите к варианту 1.

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

Программист, входящий в проект позже, вряд ли захочет вернуться к версии, которая не компилируется. Так что, ИМХО, вариант 2 - безумие.

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

Итерации: проверяя свой код, вы закрываете / сохраняете свой приклад в случае сбоя на вашей машине. Все остальное в команде из одного человека - это оформление витрин.

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

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

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

Это также хороший способ обучить себя хорошим навыкам программирования.

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

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

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

На самом деле это не имеет значения - важно то, что вы потеряли контроль над своим кодом, ваш код стал неуправляемым. Это нормально, это просто означает, что у вас есть технологический долг, и пришло время подумать о рефакторинге. Так ты расстроен? Ваш код не компилируется, у вас даже нет модульных тестов? Как вы можете думать о рефакторинге в этом случае? Не волнуйтесь. Закончите свое «ковбойское кодирование» и начните его чистить. В идеале попробуйте написать несколько тестов. У тебя нет времени на это? Хорошо, начнем с небольших улучшений.

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

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