Рекомендации по управлению версиями

Ответ 1

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

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

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

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

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

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

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

Отключу ли я, когда захочу, скажем, изменить макет меню, а затем снова объединиться? Должен ли я вступить?

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

• Могут ли мои будущие изменения нарушать работу других?

• Будет ли моя команда иметь прямое отрицательное влияние на изменения, которые я буду делать, пока не закончится?

• Является ли код кода для отправки кода?

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

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

В качестве побочного примечания: вы пишете хорошие комментарии коммита, не так ли? ПРАВИЛЬНО!? Хороший комментарий коммита обычно сообщает почему, что было сделано какое-то конкретное изменение или какая функция коммиттер работает вместо нечеткого комментария "Я сделал коммит". Это облегчает тем, кто справляется с конфликтом большого слияния, чтобы выяснить, какие изменения в строке могут быть перезаписаны и какие из них сохранить при просмотре истории изменений.

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

main -o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-o-> ...
         \           \              \
test      o-----------o--------------o---------> ...
           1.0 RC1     \ 1.0 RC2      2.0 RC1
release                 o----------------------> ...
                          1.0

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

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

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

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

Концепции ветвления и хранения удаленных репозиториев теперь ближе, чем с централизованными инструментами управления версиями. Вы могли бы считать их одними и теми же. В Mercurial (и в git) вы можете "разветкить" либо:

• Клонирование репозитория

• Создание именованной ветки

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

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

Так как просмотр через ветки немного причудливый для тех, кто привык к прямой линии коммитов, продвинутые пользователи знают, как манипулировать их версиями, чтобы история версий была "чистой", например. выбор вишни или rebase. На данный момент git docs фактически объясняют rebase довольно хорошо.

Ответ 2

Это методы, которые я придерживаюсь

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

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

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

• Я предпочитаю всегда использовать командную строку и напрямую знать свои команды VCS. Отключение, которое может вызвать интерфейс, основанный на графическом интерфейсе, может быть больно и даже повредить. Управление исходным кодом очень важно, стоит туда и делать это напрямую. Но это только мои предпочтения.

• Создайте резервную копию своего VCS. Я создаю резервную копию своего локального хранилища с помощью Time Machine, а затем я выхожу в удаленный репозиторий на моем сервере, и этот сервер также поддерживается. Только VCS на самом деле не является "резервным", он может слишком сильно понижаться.

Ответ 3

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

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

Ответ 4

Когда/как часто я должен совершать транзакции?

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

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

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

Что касается ветвления:

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

Ответ 5

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

Btw, что плохого опыта с Subversion?

Ответ 6

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

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

Q: Отключу ли я, когда захочу, скажем, изменить макет меню, а затем снова объединиться?

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

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

Ответ 7

Я согласен с другими в моменты фиксации.

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

Я использую теги для управления релизами - тег "production" всегда связан с текущим кодом prod, а в каждой версии помечен "release-YYYYMMDD". Это позволяет вам откатиться, если необходимо.