ГИТ и волей-неволей - двух ВКС войдут... один оставит [закрыт]

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

1. скорость ветвления-git занимает не более нескольких секунд.
2. конфликты-автоматическое разрешение P4Merge уничтожило недельную работу один раз. С тех пор я предпочитаю решать вручную при слиянии. Когда Git подсказывает мне о конфликте, это на самом деле конфликт. В остальное время git решает все правильно, и я экономлю кучу времени.
3. отслеживание слияний-если у вас есть одна ветвь, которая постоянно получает слияния из двух других ветвей, вы знаете, что головная боль это может быть с силой. С git головная боль сводится к минимуму, потому что результат слияния в git на самом деле является новым коммитом, который знает, кто его предки.
4. разрешения - я потерял след из числа раз, когда я пытался работать над файлом, но не мог, потому что он не был проверен в силу необходимости. Если вы работали с XCode (или любым редактором, у которого нет плагина solid Perforce SCM) в автономном режиме, вы знаете, как это может раздражать. Мне не нужно беспокоиться об этом с Git. Я делаю свои изменения. Git не останавливает меня и отслеживает их в фоновом режиме.
5. сохраняя главное дерево аккуратным - с помощью git я могу сортировать свои коммиты и приводить в порядок код, чтобы история выглядела красиво и аккуратный. Ничего из этого" проверка в этом файле, потому что он должен был быть частью предыдущей проверки " мусора. Я считаю, что они никому не помогают.
6. Stashing - ваш сервер perforce должен быть версии 2010.1 или новее, чтобы использовать команду P4 shelve.
7. создание патчей-легко сделать в git. Не знаю, возможно ли это в силу необходимости без использования командной строки.
8. почтовые патчи из GUI-опять же, git выигрывает здесь.
9. диск пространство-волей-неволей каждая ветвь является копией. Это означает, что если ваше исходное дерево огромно, ваше дисковое пространство быстро съедается. Это даже не считая дополнительного пространства, как только вы начинаете строить. Почему даже есть связь между ветвями и дисковым пространством? С git у вас может быть 100 ветвей, и только одна ветвь за раз когда-либо существовала. Если вы специально хотите работать над двумя версиями одновременно, вы можете клонировать, делать свою работу, а затем избавиться от одного клона, если хотите, не теряя что угодно.
10. Если вы находитесь на XCode4, поддержка perforce была удалена, и поддержка git теперь встроена. Если вы делаете кросс-платформенную работу, как я, это имеет большое значение. В Visual Studio можно использовать расширения git. Волей-неволей, это одинаково гадость на обеих ОС. Ну, может быть, немного больше на mac теперь с XCode4 на сцене.
11. Поиск неисправной проверки (или правил git bisect) - когда-либо пытался выполнить двоичный поиск с помощью силы, чтобы выяснить, где была введена ошибка? Вполне себе хлопот, да? Еще больше хлопот, когда были интегрированы из других ветвей в середине. Зачем? Потому что нет автоматизации для таких задач. Вам нужно написать свой собственный инструмент, чтобы поговорить с волей-неволей, и у вас обычно нет времени. С git вы даете ему начальные точки ("хорошая "точка и" плохая " точка), и он автоматизирует поиск для вас. Еще лучше, если у вас есть скрипт, который может автоматизировать процесс сборки и тестирования, вы можете подключить git к скрипту и всему процессу найти регистрация происходит автоматически. Так и должно быть.
12. отслеживание изменений в рефакторах-попробуйте разделить BigClass на SmallClass1 и SmallClass2. Поневоле, BigClass теперь перестал существовать и два новых класса (SmallClass1 и SmallClass2 присоединились к исходному дереву). Поневоле, нет никакой связи между BigClass и SmallClass1 и SmallClass2. Git, с другой стороны, достаточно умен, чтобы знать, что x% BigClass теперь находится в SmallClass1, а y% BigClass-в SmallClass2 и что BigClass перестал существовать. Теперь, с точки зрения того, кто просматривает изменения в нескольких ветвях, вы говорите мне, какой подход вы найдете более полезным - Git или Perforce В. лично я предпочитаю подход Git, потому что он более точно отражает фактическое изменение в коде. Git может сделать это, потому что он отслеживает содержимое в файле, а не сам файл.
13. централизованный или децентрализованный: Git-это DVCS

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

сколько разработчиков вы говорите об изменении?

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

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

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

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

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

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

Как говорится, если люди привыкли к GUI-клиенту для управления версиями, они не будут впечатлены git. Сейчас единственным полнофункциональным клиентом является командная строка.

какие функции Perforce используют люди?

• несколько рабочих пространств на одной машине
• нумерованные списки изменений
• филиалы разработчик
• интеграция с IDE (Visual Studio, Eclipse, SlickEdit, ...)
• многие варианты сборки
• составные рабочие пространства
• интеграция некоторых исправлений, но не другие
• etc

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

видимо GitHub теперь предлагает учебные курсы git для компаний. Каркнул их блог об этом:

Я был в кампусе Google несколько раз за последние несколько недель, помогая обучать андроидов там, в Git. Меня попросил Шон Пирс (вы можете знать его по его Git и EGit/Jgit glory – он герой, который берет на себя обслуживание, когда Junio находится за городом), чтобы помочь ему обучить инженеров Google, работающих над Андриод в переход от Perforce к Git, так что Android можно было бы поделиться с массами. Я могу сказать вам, что я был более чем счастлив сделать это.

[...]

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

выделено мной.

Я использую Perforce в течение длительного времени, и в последнее время я также начал использовать GIT. Вот мое "объективное" мнение:

Perforce особенности:

1. графические инструменты, которые, кажется, более богатые функции (например, промежуток времени просмотра, граф ревизий)
2. скорость при синхронизации с редакцией head (без накладных расходов на передачу всей истории)
3. интеграция Eclipse/Visual Studio действительно хороша
4. вы можете разработать несколько функций в одной ветви на Список изменений (я все еще не уверен на 100%, если это преимущество перед GIT)
5. вы можете "шпионить" за тем, что делают другие разработчики - какие файлы они проверили.

мерзавец характеристики:

1. у меня сложилось впечатление, что командная строка GIT намного проще, чем Perforce (init/clone, add, commit. Нет конфигурации сложных рабочих пространств)
2. скорость при доступе к истории проекта после проверки (поставляется за счет копирования всей истории, когда синхронизация)
3. автономный режим (разработчики не будут жаловаться, что недостижимый сервер P4 запретит им кодировать)
4. создание новых ветвей происходит намного быстрее
5. "основной" сервер GIT не нуждается в большом количестве Тбайт памяти, потому что каждый разработчик может иметь свою собственную локальную песочницу
6. GIT является открытым исходным кодом - нет лицензионных сборов
7. если ваша компания также вносит свой вклад в проекты с открытым исходным кодом, то совместное использование патчей намного проще ГИТ

в целом для OpenSource / распределенных проектов я бы всегда рекомендовал GIT, потому что это больше похоже на приложение P2P, и каждый может участвовать в разработке. Например, я помню, что когда я делал удаленную разработку с помощью Perforce, я синхронизировал проекты 4GB по ссылке 1Mbps один раз в неделю. Много времени было просто потеряно из-за этого. Также нам нужно было настроить VPN для этого.

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

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

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

как, например, в этом блоге сотрудника компании по разработке видеоигр: http://corearchitecture.blogspot.com/2011/09/git-vs-perforce-from-game-development.html

однако важно то, что разница в скорости между git и perforce, когда у вас есть огромный репозиторий 6gb, содержит все, от документации до каждого двоичного файла, когда-либо построенного (и, наконец, о да! фактическая история источника), как правило, исходит из того, что огромные компании, как правило, работают волей-неволей, и поэтому они настраивают его для разгрузки всех значительных операций на огромный серверный банк в подвале.

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

и, в любом случае, в конце концов, Perforce и git-это разные продукты. Git был разработан, чтобы быть исключительно СКВ, и он делает это гораздо лучше, чем волей-неволей (в том, что она имеет больше возможностей, которые, как правило, проще в использовании, в частности, по словам друга, ветвящиеся в необходимости проведения операции на открытом сердце, это должно быть сделано только специалистами :Р ) ( http://stevehanov.ca/blog/index.php?id=50 )

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

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

Я думаю, что единственное, что я знаю, что Git выигрывает, это способность "сохранять окончания строк" во всех файлах, тогда как волей-неволей, похоже, настаивает на переводе их в формат Unix, Dos/Windows или MacOS9 ("\n", "\r\n" или "\r).

это настоящая боль, если вы пишете сценарии Unix в среде Windows или в смешанной среде ОС. Это даже не возможно установить правило на основе расширения файла. Например, он будет конвертировать .ш .бить. ,unix файлы в формате Unix, и обратить .КПК. ,bat или. com файлы в формате Dos / Windows.

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

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

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

Это просто то, что я думаю, дает GIT большое преимущество, и я не думаю, что это было упомянуто выше.

EDIT: после того, как вы использовали Perforce немного дольше, я хотел бы добавить еще пару комментариев:

A) что-то, что я действительно пропустил в Perforce, является четким и экземпляром diff, включая измененные, удаленные и добавленные файлы. Это доступно в GIT с git diff команда, но в принудительном порядке файлы имеют чтобы быть извлеченным до записи их изменений, и хотя вы можете настроить свои основные Редакторы (например, Eclipse) для автоматического извлечения файлов при их редактировании, вы можете иногда редактировать файлы другими способами (Блокнот, команды unix и т. д.). И новые файлы, похоже, не добавляются автоматически вообще, даже используя Eclipse и p4eclipse, что может быть довольно раздражающим. Поэтому, чтобы найти все изменения, вы должны запустить "Diff against..."на всю рабочую область, которая в первую очередь занимает некоторое время для запуска, а во-вторых включает в себя все виды ненужных вещей, если вы настроены весьма сложные списки исключений, что приводит меня к следующему пункту.

B )в GIT я нахожу.gitignore очень прост и удобен в управлении, чтении и понимании. Однако списки игнорирования/исключения рабочей области, настраиваемые в принудительном порядке, кажутся громоздкими и излишне сложными. Я не смог получить никаких исключений с помощью подстановочных знаков. Я хотел бы сделать что-то вроде

-//Server/mainline/.../target/...   //Svend_Hansen_Server/.../target/...

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

-//Server/mainline/projectA/target/...  //Svend_Hansen_Server/projectA/target/...
-//Server/mainline/projectB/target/...  //Svend_Hansen_Server/projectB/target/...
...

и аналогичные строки для папок bin,.classpath и .проецировать файлы и многое другое.

C) в силу необходимости есть весьма полезные списки изменений. Однако предположим, что я делаю группу изменений, проверяю их все и помещаю их в список изменений, чтобы затем работать над чем-то еще, прежде чем отправлять этот список изменений. Если я позже внесу изменения в один из файлов, включенных в первый список изменений, этот файл все равно будет в этом списке изменений, и я не могу просто позже отправить список изменений, предполагая, что он содержит только те изменения, которые я изначально добавил (Хотя это будут те же файлы). В GIT, если вы добавите файл и внесете в него дополнительные изменения, эти изменения не будут добавлены (и все равно будут отображаться в git diff и вы не сможете зафиксировать файл без предварительного добавления новых изменений. Конечно, это не полезно Так же, как список изменений может быть, поскольку у вас есть только один набор добавленных файлов, но в GIT вы можете просто зафиксировать изменения, поскольку это на самом деле не подталкивает их. Вы могли бы работать над другими изменениями, прежде чем нажимать их, но вы не сможете нажимать что-либо еще, что вы добавите позже, не нажимая на прежние изменения.

У меня нет опыта работы с Git, но у меня есть с Mercurial, который также является распределенным VCS. Это действительно зависит от проекта, но в нашем случае распределенный VCS подходит для проекта, поскольку в основном устраняются частые сломанные сборки.

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

вот что мне не нравится в git:

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

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

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

Git активно поощряет людей переписывать историю, и это, вероятно, одна из причин этого. Каждый нормальный VCS делает переписывание истории невозможным для всех, кроме администраторов, и гарантирует, что у администраторов нет причин рассматривать его. Поправьте меня, если я ошибаюсь, но, насколько я знаю, git не дает возможности предоставить обычные пользователи пишут доступ, но запретить им переписывать историю. Это означает, что любой разработчик с обидой (или кто все еще боролся с кривой обучения) может уничтожить всю кодовую базу. Как нам его затянуть? Ну, либо вы делаете регулярные резервные копии всей истории, т. е. вы держите историю в квадрате, или вы запрещаете доступ к записи для всех, кроме некоторых бедных sod, которые получат все различия по электронной почте и объединят их вручную.

давайте возьмем пример с финансированием большого проекта и посмотрите, как git работает для них: Android. Однажды я решил поиграть с самой системой android. Я узнал, что я должен был использовать кучу сценариев под названием repo, чтобы добраться до их git. Некоторые из РЕПО выполняются на клиенте, а некоторые на сервере, но оба, по их самому существованию, иллюстрируют тот факт, что git является неполным в любом качестве. Случилось так, что я не мог вытащить источники около недели, а затем вообще сдался. Мне бы пришлось тянуть действительно огромный объем данных из нескольких разных репозиториев, но сервер был полностью перегружен такими людьми, как я. РЕПО было тайм-аут и не смог возобновить с того места, где он был тайм-аут. Если git настолько распространен, вы бы подумали, что они сделали бы какую-то одноранговую вещь, чтобы облегчить нагрузку на этот сервер. Git распространяется, но это не сервер. Git + repo-это сервер, но РЕПО не распространяется, потому что это просто специальная коллекция хаков.

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

даже если бы вы верили в распределенную вещь, git все равно был бы беспорядком. Зачем например, это ветка? Они говорят, что вы неявно создаете ветвь каждый раз, когда клонируете репозиторий, но это не может быть то же самое, что ветвь в одном репозитории. Так что это, по крайней мере, две разные вещи, которые называются ветвями. Но тогда вы также можете перемотать РЕПО и просто начать редактирование. Это похоже на второй тип ветви, или что-то другое снова? Возможно, это зависит от того, какой тип РЕПО у вас есть - о да - по-видимому, РЕПО тоже не очень четкое понятие. Есть нормальные и голые. Вы не можете нажать на нормальный, потому что голая часть может выйти из синхронизации с его исходным деревом. Но вы не можете cvsimport к голому, потому что они не думали об этом. Таким образом, вы должны cvsimport к нормальному, клонировать его к голому, который разработчики ударили, и cvsexport, что к рабочей копии cvs, которая все еще должна быть проверена в cvs. Кого это может беспокоить? Откуда взялись все эти осложнения? От самой распространенной идеи. Я угробил gitolite'е в конце потому что это накладывало на меня еще больше этих ограничений.

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

в силу необходимости вам редко нужны ветви, потому что вы можете жонглировать наборами изменений очень гибким способом. Например, обычный рабочий процесс заключается в том, что вы синхронизируетесь с последним известным товаром версия на магистрали, а затем написать свою функцию. Всякий раз, когда вы пытаетесь изменить файл, разница этого файла добавляется в ваш "набор изменений по умолчанию". Когда вы пытаетесь проверить набор изменений, он автоматически пытается объединить новости из mainline в ваш набор изменений (эффективно перебазируя его), а затем фиксирует. Этот рабочий процесс выполняется без необходимости его понимания. Mainline таким образом собирает историю изменений, которые вы можете довольно легко вишня выбрать свой путь через позже. Для например, предположим, что вы хотите вернуть старый, скажем, тот, который был до позапрошлого. Вы синхронизируетесь с моментом до оскорбительного изменения, отмечаете затронутые файлы как часть набора изменений, синхронизируетесь с моментом после и сливаетесь с "всегда моим". (Там было что - то очень интересное: синхронизация не означает, что у вас есть то же самое-если файл редактируется (т. е. в активном наборе изменений), он не будет заблокирован синхронизацией, но помечен как должный для разрешения.) Теперь у вас есть список изменений, который отменяет тот, что обидел меня. Слияние в последующих новостях, и у вас есть список изменений, которые вы можете плюхнуться на верхней части магистрали, чтобы иметь желаемый эффект. Не мы переписываем историю.

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

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

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

У вас также есть триггеры и настраиваемые формы для утверждения обзоров кода, ссылок на bugzilla и т. д., И, конечно же, у вас есть ветви, когда они вам действительно нужны. Это не clearcase, но это близко, и это мертво легко настроить и поддерживать.

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

использование GIT в качестве замены для плохого управления строкой кода является общим. Многие из недостатков Perforce являются результатом плохих стратегий ветвления. То же самое для любого другого централизованного инструмента. Если вам нужно создать кучу веток вы делаете что-то неправильно. Почему разработчикам нужно создавать так много филиалов?

кроме того, почему работа отключена так важно в любом случае? Просто чтобы кто-то мог работать в поезде? Это почти единственное место в наши дни, где вы не можете получить беспроводную связь соединение. И даже в большинстве поездов есть приличный Wi-Fi.