Почему Mercurial проще, чем Git?

При рассмотрении сравнений мне кажется, что между их наборами функций может быть соотношение 1: 1. Тем не менее, часто цитируемое утверждение гласит, что «Mercurial проще». На чем основано это утверждение? (если есть)

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

Git Version

git filter-branch --commit-filter '
        if [ "$GIT_COMMITTER_NAME" = "<Old Name>" ];
        then
                GIT_COMMITTER_NAME="<New Name>";
                GIT_AUTHOR_NAME="<New Name>";
                GIT_COMMITTER_EMAIL="<New Email>";
                GIT_AUTHOR_EMAIL="<New Email>";
                git commit-tree "$@";
        else
                git commit-tree "$@";
        fi' HEAD

Mercurial версия:

Файл авторы.convert.list:

<oldname>=<newname>

Командная строка:

hg convert --authors authors.convert.list SOURCE DEST

Теперь, какой из них выглядит проще в использовании?

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

Для меня это удобство использования. Git очень ориентирован на Linux с Linux. Это означает командную строку, справочные страницы и выяснение этого для себя. У него был очень плохой графический интерфейс (примечание: я основываю это на msysGit примерно год назад), который, кажется, просто мешал мне. Я едва мог использовать это

Командная строка была хуже. Будучи ориентированной на Linux программой, в Windows ее было очень сложно использовать. Вместо собственного порта они просто обернули git MinGW (Think cygwin), что значительно усложнило работу с ним. MinGW - это не командная строка Windows, а просто другой. Это безумие, что это единственный способ работать с Git. Даже в Linux казалось, что единственный способ - работать с прямой командной строкой. Такие проекты, как RabbitVCS, помогли некоторым, но не были очень мощными.

Подход, ориентированный на командную строку и являющийся программой linux, означал, что почти все руководства, справочная документация и вопросы форума / QA основывались на выполнении чудовищных команд, как описано выше. Основные команды SCM (commit, pull, push) не так сложны, но больше и сложность растет в геометрической прогрессии.

Я также ненавижу то место, где многие пользователи OSS git, кажется, тусуются: Github. Когда вы в первый раз заходите на страницу github, вы получаете все, что вы можете сделать. Для меня страница проектов git выглядит хаотично, страшно и чрезмерно мощно. Даже объяснение того, что представляет собой проект, опущено вниз. Github действительно ранит людей, у которых еще не настроен полноценный сайт. Его проблема отслеживания также ужасна и запутана. Функция перегрузки.

Пользователи Git также казались очень культовыми. Похоже, что пользователи Git всегда начинают «священные войны», из-за которых DVCS лучше, что заставляет пользователей Mercurial защищаться. Такие сайты, как http://whygitisbetterthanx.com/, демонстрируют высокомерие и почти менталитет «Используй мое программное обеспечение или умри». Много раз я приходил в разные места помощи только потому, что не знал X, заранее использовал X, использовал Windows и т. Д. Это безумие.

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

С Mercurial у меня нет бессмыслицы по SSH (SSH - ад в Windows), у меня нет тупо сложных команд, у меня нет последователей-культов, у меня нет сумасшествия. Mercurial просто работает.

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

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

Mercurial также работает в первый раз с небольшими настройками. На ЛЮБОЙ ОС я могу просто установить TortoiseHg и получить все нужные мне функции (в основном команды контекстного меню) без необходимости искать разные Guis. Также отсутствует настройка SSH (половина руководств говорит об использовании Putty, Plink и Pagent, а другая половина - об использовании ssh-keygen). Для новых пользователей TortoiseHg требует минут для настройки, в то время как Git занимает от 30 минут до часа с большим количеством поиска в Google.

Наконец, у вас есть онлайн-репозитории. Эквивалентом Githubs является BitBucket, в котором есть некоторые проблемы, о которых я говорил выше. Однако есть и Google Code. Когда я захожу в проект Google Code , у меня не возникает перегрузка функций, я получаю хороший чистый интерфейс. Google Code - это скорее комбо онлайн-репо / веб-сайта, которое действительно помогает проектам OSS, у которых нет существующей настройки сайта. Я чувствовал бы себя очень комфортно, используя Google Code в качестве веб-сайта моих проектов в течение достаточно долгого времени, создавая его только тогда, когда это абсолютно необходимо. Его средство отслеживания ошибок также мощно, прекрасно вписывается между почти бесполезным средством отслеживания ошибок Github и чудовищем Bugzilla .

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

Git против Mercurial

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

Git Concepts

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

Контекст: я ежедневно использую и Mercurial (для работы), и Git (для сторонних проектов и с открытым исходным кодом). Я в основном использую текстовые инструменты с обоими (не IDE), и я нахожусь на Mac.

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

1. Отсутствие индекса. Индекс - это мощный инструмент, позволяющий использовать многие функции Git, но это также дополнительный слой, который добавляет шаг ко многим вещам, которые я регулярно делаю. Рабочий процесс Mercurial больше похож на svn.
2. Номера ревизий вместо шас. Это небольшая вещь, которая, как мне кажется, значительно облегчает работу с ежедневными командами в Mercurial. Проще вставить несколько номеров ревизий в вашу голову во время перебазирования, слияния и т. Д. При написании команды, чем делать то же самое даже с укороченными шасами.
3. Ветви. Подход Git к ветвям с помощью фиксации имен мощен и существенно отличается от других систем контроля версий. Это делает определенные вещи намного проще. Я считаю, что подход Mercurial соответствует SVN мышления немного лучше и облегчает визуальное понимание истории отрасли. Это может быть просто предпочтением.

Это очень субъективно и зависит от одного человека к другому, но да, я бы сказал, что для кого-то совершенно нового для VCS или для кого-то из одной из "старых школ" VCS Mercurial будет проще.

Например, добавление файлов, отсутствие индекса в Hg, простота возврата к какой-то старой ревизии и переход оттуда (просто обновление и фиксация), как некоторые из наиболее «очевидных» примеров. Теперь большинство функций одной системы можно эмулировать в другой, и наоборот, но это требует определенных знаний в Git, тогда как в Mercurial значения по умолчанию (если вы позволите мне так их называть) довольно «удобны для пользователя». Эти мелочи - переключение здесь и там, неочевидное поведение в одной команде и так далее ... все это складывается, и в конце концов, одна система кажется более простой в использовании, чем другая.

Просто чтобы завершить ответ; Я использую git, но когда я рекомендую VCS для тех, кто «новичок в них», я почти всегда рекомендую Mercurial. Я помню, когда он впервые попал в мои руки, он был очень интуитивным. По моему опыту, Mercurial производит меньше wtf / мин, чем Git.

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

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

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

Встречный пример сложности GIT / mercurial: поддержка Nice GIT встроена в XCode на Mac. Менее прост в использовании XCode с Mercurial, чем GIT.

До сих пор мой опыт работы с GIT заключался в том, что я запутался и растерялся, и мне нужно больше обращаться к документации при его использовании. Я полагаю, что было написано много документации, но ничего, что позволило бы мне ее «проглотить». Во-вторых, я могу легко модифицировать и расширять Mercurial в Python, и, поскольку я адепт в Python, и, как любой действительно может быстро выучить Python, это кажется мне преимуществом. Я также знаю C и пишу расширения Python на C, поэтому я думаю, что когда-нибудь, если мне понадобится, я мог бы легко написать расширение Git на C.

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

Я не настолько пристрастен, чтобы быть 100% промеркуриантом и 100% антигитом. Сейчас я чувствую себя более комфортно на Mercurial, на Windows и на Linux, и когда я начну больше работать на Mac, я ожидаю, что попробую придерживаться XCode + GIT.

Обновление 2013: Теперь я использовал ртутный И GIT достаточно долго , чтобы найти некоторые функции , которые я хочу это было , что Git имеет, например, этого вопрос о стратегии слияния. На самом деле Git удивителен, если его трудно освоить, и иногда сводит с ума.

Есть несколько вещей, которые IMO могут оттолкнуть новых пользователей от Git:

1. Культура Git больше ориентирована на командную строку. Хотя оба инструмента имеют тенденцию слишком фокусироваться на командной строке (как я уже говорил несколько раз, инструкции командной строки могут быть мощными и более гибкими, но они не являются хорошей маркетинговой стратегией ), это гораздо больше относится к Git. Принимая во внимание, что Mercurial имеет де-факто стандартный графический инструмент GUI в TortoiseHg, который является даже опцией загрузки по умолчанию для пользователей Windows на домашней странице Mercurial, у Git есть несколько конкурирующих внешних интерфейсов GUI (TortoiseGit, Git Extensions, gitk и т. Д.), Которые плохо рекламируются на веб-сайте Git, и которые все равно являются полным бельмом на глазу. (Черный текст на красных метках? Да ладно, TortoiseGit, вы можете сделать это лучше!) В сообществе Git также гораздо более распространенное мнение, что люди, которые используют инструменты с графическим интерфейсом, не являются подходящими разработчиками программного обеспечения.

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

3. Документация и внутренняя сложность:

   $ hg help log | wc -l
   64
   $ git help log | wc -l
   912
   

Одна вещь, о которой я могу думать, это

git add .
git commit -am "message"

против

hg ci -Am "message"

git commit -aне добавляет вновь созданные файлы, hg ci -Aделает, что означает, что то, что требует двух команд с git, может быть сделано одной командой в Mercurial. Опять же, «меньше печатать» не обязательно означает «более удобный».

Потому что это.

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

Один простой пример - относительно небольшое количество флагов и аргументов командной строки, необходимых для mercurial по сравнению с git. Промежуточная область и поведение команды add в git также добавляет больше сложности, чем необходимо. Трио сброса, извлечения и возврата и их множественные перестановки добавляет огромную сложность, которая была совершенно ненужной, когда вы наблюдаете прямую природу возврата и обновления на Mercurial.

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