Pull to refresh

Comments 138

Столько всякого, а Sublime Merge не упомянули.

Согласен, Sublime Merge это лучшее, что появилось со времён поворота SourceTree куда-то не туда. Все самое базовое есть, в том числе удобная работа с hunk'ами для частичного коммита, основные понятия гита не переизобретает своими абстракциями, не упрощает и так простое. Дополнительно радует интеграция с Sublime Text, очень легко переходить туда-обратно.

У Sublime Merge визуализация веток плохо сделана, на паре паралельных веток уже ничего не понятно. И лайаут неудачный, например чтобы посмотреть текущие staged\unstaged файлы, надо выделить в списке коммитов верхний пункт, изза чего постоянно путаешься, если ткнул на другой коммит в ветке.

Возможно не попал в список из-за нестабильной работы. Во всяком случае у меня он регулярно валится.

Чего-о-о? Это ж что вы с ним делаете-то...


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

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

К сожалению, не пользовался и не пробовал Git Extensions. Своё знакомство с Git-клиентами начал с GitKraken и Tower. По большей части из-за того, что они входили в студенческий пакет ПО от GitHub. В итоге понял, что мне хватает возможностей работы с Git, доступных из IDE. Иногда пользуюсь Lazy Git, но его сложно назвать инструментом с полноценным GUI

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


Так что всё-таки лучше бы его добавить в список...

Да, обязательно добавлю Git Extensions и выше ещё обратили внимание на Sublime Merge

Поддерживаю про Git Extensions. Как 15 лет назад начал пользоваться, так и продолжаю. Пробовал другие клиенты, но по функциональности с ним может сравниться только Kraken. Но он платный, а Extensions нет :)
Из серьезных минусов:

  • windows only. Так что на маке приходится крутиться с Soutcetree

  • нет темной темы оформления :) они в какой-то версии её выкатили, но она была кривая-косая и они ее откатили

Хм, а что в их тёмной теме было кривого-косого?


Вроде в 3.5.4 тёмная тема есть и работает. Но я ей не пользуюсь, так что могу чего-то не заметить.


А вот в свежей 4.1.0 тёмная тема как раз есть, но кривая-косая (половина цветов остались от светлой).

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

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

Еще смена темы требовала перегрузки, и она не синхронизировалась с системой.

На рабочем компе стгит тортуаза + git extensions. Некоторые вещи в тортуазе проще делаются - два коммита объдинить, тег перенести... А что посложнее - тут уже extensions. Пробовал что-то ещё - не зашло.

ну он же не на электроне, ему тут не место!

Другой вариант использовать `git gui` и `gitk --all` - чье основное преимущество в том, что, независимо от платформы, UI почти идентичен, что несколько облегчает жизнь если приходится скакать между разными ОС.

вот да - я попробовал и тортойз и сорстри, и встроенные гуи, и все равно `git gui` и `gitk --all` удобнее и переносимее всего этого зоопарка

А та же Idea тоже позволяет работать

Мне во многих программах, не нравиться, что нельзя отображать изменения ввиду дерева, только списком
GitHub Desktop долго страдал этим
https://github.com/desktop/desktop/issues/2417

Но походу исправили, я уже не смотрел

Да, сейчас в основном пользуюсь только встроенными инструментами в WebStorm

gui и git = плохо, только если дерево красивое посмотреть полистать, и то это можно делать в удалённом репозитории. Если начинающий изучать git человек лучше начинать с  консоли.

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

А в консоли всегда всё понятно, всегда понятно текущее состояние репы и что происходит в данный момент.

 

И gui скорее всего внутри выполняет обычные команды git, т.е. многовесящая надстройка.

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

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

А вот и нет.


Когда у вас в проекте 200 добавленных файлов — очень сложно понять по одному только git status что из них 100 файлов — лишние и должны быть заигнорены. Или вот изменено 10 файлов, и тяжело вспомнить что два из них содержат временные изменения, которые не должны попасть в коммит. В Git Extensions такое видно сразу же, а вот от тех кто пользуется консолью я постоянно вижу мусорные изменения.

Гуй для индексации только и подходит

"мусорные изменения" - зависят от человека, врятли тут важно консоль или gui

(какие именно изменения смотрятся как в консоли так и в gui глазами).

 (у нас видимо разные сферы деятельности т.к. у меня и бинарников то нет)), а выкатываются именно исходники (php) )

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

Т.е. даже в gui вы глазами наверно смотрите что надо или не надо (игнорите или делаете правила), и в консоли вы можете игнорить определённые форматы файлов или разделы, и добавлять разделы разом или файлы по маске.

(gui в моём понимание просто надстройка это чуть больше чем консоль в плане графики просто в плане визуала, и чисто лично у вас на вашем ПК делает красивости )

---

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

 

 

GUI — это не просто красивость, это ещё и плотность информации.


Взгляните что одновременно показывает знакомый вам Fork в окне создания коммита, и сравните что показывает git add -i


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

Это очень странно. Возможно, недоработка Fork. Тот же Git Extensions прекрасно уведомляет о странных состояниях (скажем, что репозиторий посреди операции rebase)


Кстати, если уж мы начали обсуждать невнимательных коллег — я видел кучу вопросов на ruSO из разряда "ничего не работает, помогите прочитать что мне пишет git status"

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

Это вполне себе стандартная ситуация в начале разработки.


И да, там половина файлов совершенно точно автогенерённые — а именно, результаты сборки. И если человек работает в консоли, он в такой ситуации делает git add . и здравствуй 100 изменённых файлов в каждом коммите пока кто-нибудь с GUI их из репы не почистит.

логичный вопрос - нужны ли автосгенерированные файлы в репозитории?

обычно такие директории сразу уходят в gitignore

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

Так они и не нужны. Только у пишущего git add . не будет ни шанса вовремя заметить что он делает.


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

Это нормальная ситуация - рефакторинг, переименование глобальной сущности, которая используется почти везде.

Сударь, Вы же в консоли! Весь спектр утилит приходит на помощь: less, grep и далее по списку. Да и команды самого git на банальном status не заканчиваются, а только начинаются. Освойте хотя бы diff, log, show, и поймёте, что без гуя можно вполне неплохо жить.

Зачем, к примеру, "вспоминать", какие изменения были сделаны в том или ином файле? Смотрим через diff и понимаем.

без гуя можно вполне неплохо жить.

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

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

Сам пользуюсь в основном консолью, но в некоторых случаях пользую "родной" клиент git gui (есть в поставке git для windows, есть, наверное, в репозитории любого дистрибутива линукса) и другие графические средства, из него вызывающиеся. Их возможности не слишком впечатляющи, но мне пока хватает.

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

Или я неправильно понял смысл слова "цепочка"?

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

Ой, а знаете чё скажу? Нет лучшего инструмента. Мне приходится пользоваться разными GUI и консольным гитом (в том числе и fugitive для vim). Звучит фигово, но деваться не куда(. А тут споры о том, кто каким одним функционалом одной проги пользуется, которого нет в другой проге.

Вот у вас в консоли git status показывает 100 изменений. Теперь вы будете git diff каждому прописывать или что?


В GUI же я вижу результат git status и git diff одновременно в одном окне, и git log с git show в другом.

В обычной ситуации я буду делать либо `git diff` без аргументов (показывает все изменения, кроме новых файлов), либо `git add -p` (смотреть изменения по кускам и сразу решать, что добавлять в индекс, а что нет).

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

Ваш вопрос очень хорош тем, что он подсказывает, где именно могут лежать источники расхождений между любителями cli и любителями gui. Возможно, что дело в частоте, объёме и сложности просматриваемых изменений. Я давно привык уже делать собственные коммиты максимально часто (даже после самых простых изменений). Подавляющую часть времени я сижу с "чистым статусом", а когда ситуация меняется, то новые изменения либо добавляются в коммит, либо целиком отбрасываются. Последствия этой тактики такие:

  1. Вызывать какой-либо gui на такое частое действие (временами вплоть до нескольких раз в минуту) начинает быстро надоедать. Пока программа запустится, пока отрисует ситуацию, пока голова разбертёся в этой картине, пройдёт заметно много времени.

  2. С другой стороны, команды в cli можно набивать молниеносно быстро (привычки пальцев + алиасы по вкусу), а отсмотреть и отрешать сравнительно небольшой объём достаточно однородных изменений нетрудно.

  3. Частые повторы позволяют закрепить привычку работать через cli. Формируется мышечная память и укрепляются маршруты в голове ("в такой-то ситуации используем такую команду").

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

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

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

А зачем вы его закрываете? Терминал-то небось у вас открыт постоянно...


С другой стороны, команды в cli можно набивать молниеносно быстро (привычки пальцев + алиасы по вкусу), а отсмотреть и отрешать сравнительно небольшой объём достаточно однородных изменений нетрудно.

Ну да, ну да. Посмотрю я как вы молниеносно быстро git add projects/backend/Some.Project.Name/Some/Namespace/FooCommandHandler.cs наберёте...


А что до мышечной памяти — она и в gui неплохо так формируется.

Да легко:

$ git add **/FooCommandHandler.cs

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

$ git status

что у тебя по wildcards добавилось.

где именно могут лежать источники расхождений между любителями cli и любителями gui.

Они лежат в религиозной плоскости. Gui - это инструмент, а консоль - религия.

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

Они лежат в религиозной плоскости. Gui - это инструмент, а консоль - религия.

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

А вот когда упираются в один инструмент, и настаивают на его применении всеми вокруг, а все остальное считают ересью, это уже религия

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

Консольщики на этом поприще более заметны только потому, что их религия

Это мягко говоря не правда, примеров религиозного отношения к gui, я например сходу вспомнить не могу

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

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

Это мягко говоря не правда, примеров религиозного отношения к gui, я например сходу вспомнить не могу

А как же постоянное запугивание адом командной строки по разгым поводам?

А как же постоянное запугивание адом командной строки по разгым поводам?

Ну cli действительно куда менее понятный интерфейс для людей далеких от ойти

Да, ещё момент.


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

На сервер надо выкатывать артефакты после сборки, а не исходники. Даже в мире Javascript давным-давно победили транспайлеры и бандлеры.


git на сервере не нужен.

git на сервере не нужен.

Например, если это сервер для CI/CD, или чтобы хранить в git конфиги (я давно так и делаю, я не админ серверов, но у меня всегда для разработки cтоит несколько виртуалок под Линуксом без GUI).

Ну и поправь комфортно конфиги на десктопе с гуем и пусть CI/CD их отправит на нужные сервера. Чистая же задача деплоя.

Для коммитов, просмотра дерева, переключения веток, diff/annotate удобен гуй. Что посложнее – да, в консоли, и разбираться обязательно (отсутствие гуя не должно сильно напрягать).

я бы сказал наоборот. слияние веток, откат какого-то коммита , разбор ошибок при слиянии удобнее делать в гуи. а консоль она разве что на сервере нужна чтоб делать git pull git checkout

Слияние веток – да, тоже предпочитаю в гуе, но "посложнее" бывает сильно сложнее – например, примерно всё, что связано с git reflog (и не говорите мне, что он не нужен: я был вынужден в него полезть примерно на третий день после перехода с hg на git, разломав свою локальную репу).

В общем, git – тот ещё конструктор, и предусмотреть gui для всего, что можно из него собрать – сложно и не нужно. Плюс когда у человека возникают вопросы по git – проще ему сказать командную строку, в gui пусть сам переводит, если ему надо.

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

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

при хорошем гуи кли не нужно.

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

Я в вскоде пробовал ребейз через гуй сделать, всё сломалось) Пришлось в консоли.

Ну да, ну да, уж запрятана так запрятана...

Интересно, а расширенные опции на скрине содержат --rebase-merges? Из Jetbrains Rider не нашёл как запустить такую штуку, приходилось через консоль делать

Да, содержат. Хотя лично я никогда не понимал зачем она нужна — что с неё, что без неё rebase при наличии слияний работает хреново.

Знаете, я говорил про коллегу, который во всём компетентен, но на 3-м году опыта с гитом вот это выдал и вы не он, и насколько я могу сейчас судить, вы с ним разными GUI пользуетесь.

при работе по ssh лично мне нужно 3 команды hg pull -u hg checkout branch_nme hg update. работать с репой на сервере плохая идея. обычно там токены только для чтения реп а не записи. но при необходимости нужные команды гуглятся. с гуи вход легче. новичку проще понять что надо делать когда перед глазами есть вся история. с командами это гораздо тружнее. Когда уже есть понимание работы то загуглить как в гите смерджить ветки например уже горахдо легче. особенно если догадатся предварительно поэксперементировать на копии репы и результат контролировать через тот же гуи.

Я повторюсь, а как вы будете в скриптах GUI использовать? Тот жеpasswordstore активно этим пользуется.

По работе на сервере. Да всё нормально с этой идеей, если не класть туда личный ssh ключ.

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

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

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

gui скорее всего внутри выполняет обычные команды git,

Аналитика которую мы заслужили

Что внутри конкретно перечисленных в статье gui я не видел (есть там лог команд гита или нет) как и не пользовался. А вывод у меня такой т.к. давно когда то пользовался TortoiseHg  это тоже gui но для hg, (сейчас специально запустил перепроверить, версия 5.0.2) в нём всё что делается графически и кнопочками, внизу в консоли дублируется консольными командами (+ можно выполнить команды прямо там, без нажатия кнопок), поэтому у меня сложилось такое мнение сразу о всех gui систем контроля версий.  (на картинке нажатие кнопки в gui выполнило команду внизу + какие то данные для информации вывела)

gui и git = плохо, только если дерево красивое посмотреть полистать, и то это можно делать в удалённом репозитории.

Субъективное мнение.

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

А я видел, что люди путаются в командах git и без gui.

А в консоли всегда всё понятно, всегда понятно текущее состояние репы и что происходит в данный момент.

Кому как.

И gui скорее всего внутри выполняет обычные команды git, т.е. многовесящая надстройка.

Ну да, как и компиляторы, конвертеры и другие инструменты - это стандартная вещь.

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

Один только git pull уже создаёт слияние по умолчанию.


И любая попытка исправить это через интерактивный rebase, скорее всего, приведёт к слиянию результата rebase с исходным состоянием. Кучу раз я это наблюдал: меня просят исправить в хлам запутанную историю, я исправляю, потом коллега делает git pull и всё по новой.


Без графических инструментов слишком тяжело заметить насколько ужасна история и как в ней будет тяжело разобраться в будущем.

А не надо делать git pull. Только git fetch и git rebase. Этого обычно хватает.

Можно сразу делать git pull --rebase=true или git pull --ff-only (но второй вариант может не сработать).

Я юзаю второй вариант, а места где он не сработал подсвечивают запахи на исправление.

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

Дада. Особенно он не нужен, когда в проекте 4 уровня вложенности субмодулей.

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

Пробовал разные GUI и остановился на Git-клиенте, встроенный в IDE от JetBrains.

Например из бесплатных:

Платформы: Windows, macOS, Linux

Цена: Бесплатная, на базе открытого исходного кода

Да, она классные. Но, к сожалению, это не полноценные Git клиенты, а встроенные в IDE. Отдельный не планируют разрабатывать, хотя такая issue очень популярная (более 400 плюсов).

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

На мой взгляд достаточно поверхностный обзор, хотя, возможно, у меня высокие ожидания от подобной статьи. В разное время много работал с command line, git extensions, smartgit, tortoise git.

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

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

P.S. если честно не понял про smartgit и трекеры. Вроде как с jira работает как ожидается

А как же черепашка, TortoiseGit. Черепашка, в виде отдельных клиентов, есть и по mercurial и под svn.

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

К примеру, объединение двух коммитов (когда последний коммит нужно подклеить к предпоследнему) - в черепашке это просто выделить два коммита и выбрать Combine to one commit и дальше поправить описание. А во что это выльется командами?

Аналогично - перенести тег. Просто Create tag on this commit и там открыжить forse.

А во что это выльется командами?

git commit --amend

Я обычно описание в таких случаях не правлю, поэтому

git commit --amend --no-edit

Это до того как коммит появился. А если коммит уже создан — это git rebase -i хеш_коммита_который_ещё_надо_найти

Да, я неправильно понял задачу, наверное из-за того, что мне ни разу в жизни не приходилось объединять два последних коммита и даже сложно представить, зачем это может понадобиться. А вот amend – регулярно =D.

хеш_коммита_который_ещё_надо_найти

Вроде речь идёт о двух последних коммитах и искать ничего не надо, не?
git log -2 – или я опять что-то неправильно понял?

А мне не сложно представить. Сначала в режиме потока накидиваешь коммиты, как придется (=добился более-менее правильной работы), затем ребейзишь все добро. И "последние два коммита" здесь только для примера. С тем же успехом это могут быть "последние 3", "от последнего 10-го до последнего 6-го", и куча других вариантов

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

Ну вот надо открыть git log -2, скопировать оттуда хеш коммита в буфер обмена мышью, после чего написать git rebase -i и вставить хеш из буфера обмена (в зависимости от терминала, может снова потребоваться мышь). Зачем всё это когда можно с самого начала отдать команду мышью?


На самом деле ещё можно написать git rebase -i HEAD~2, только вот… этот синтаксис с тильдой я две недели искал, он в мануале к гиту находится в довольно неочевидном месте.

Тут самое сложное запомнить, тильда там или крышечка (^). Для тех, кто не знает — крышечка для выбора родителя коммита (у мердж-коммитов их более одного (обычно 2)). Как правило, мерджей у вас мало и вы их не ребейзите, поэтому HEAD^2 в большинстве случаев не существует (это второй родитель текущего состояния ветки)

А ещё вместо HEAD можно использовать @, т.е. работают как @^, так и @~2

Привык к работе с Git в VSCode (+ функционал от Git Lens), что не пользовался консолью уже года полтора, настолько удобно всё сделано

Я в связке с Git Graph использую, но все команды всё равно через консоль.

Пробовал Sourcetree, SmartGit, GitKraken. Последний сразу удалил - при открытии одной репы сразу скушал 1G оперативы.

Потом наткнулся на Fork и успокоился :)

Иногда открываю SmartGit.

p.s. голосовалка напрашивается ;)

Fork можно бесплатно использовать, не покупая лицензию?

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

TortoiseGit. И SVN-новая и GIT-овая черепахи просты и удобны. Плюс встроеный git в Idea.
Sourcetree пробовал, но об больше путает, чем помогает

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

Увы, если вам нужен кросс-платформенный клиент (с нормальным линуксом) то единственным внятным решением остается ГитКракен. Пользовался практически всем из списка, но последние года 2 покупаю ГитКракен.

Главный недостаток ГитКракена - забагованный GUI. Это хорошо проявляется на больших резпозиториях или где много файлов под LFS. Иногда тупо фризится весь интерфейс и нет возможности ничего сделать кроме как прибить и запустить заново клиент. Плохо работает с приватными сабмодулями. Часто не может сделать update, приходится открывать вручную, делать fetch, и только после этого уже в основной ветке update. Или приходится pull+gc делать вручную через консоль, а потом уже пользоваться GUI. Так же очень много мест (те же логи) где текст выделяется но не копируется.

Из плюсов - хорошо из коробки работает интеграция с GitHub/GitLab.

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

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

Такое чувство что под капотом самописные алгоритмы и контейнеры на js.

Лучше чем Magit еще ничего не придумали, но у него слишком большой порог входа в виде Emacs :)

Зато редактировать комиты, рибейзить, делать blame - одно удовольствие.

Тоже хотел написать. Самое лучшее решение, к тому же опен сорс

А где вариант в голосовании "не пользуюсь вообще"? Я лично не пользуюсь, только, если надо быстро открыть какую-то предыдущую версию файла (тогда делаю это просто в Visual Studio), или когда надо какую-нибудь нетривиальную историю посмотреть (редко нужно, а так, обычно самого банального git log хватает). Стоит только модуль Posh-Git для PowerShell.

Также клиент работает только с GitHub, что заметно ограничивает сценарии его использования.

GitHub Desktop прекрасно работает с любым репозиторием. В том числе - удаленным. Я в частности его совместно с gitea использую

Не упомянут GitAhead, к которому вопросы есть, но он от этого хуже не работает.

Какие вопросы? Ну и кстати он заброшен, но есть форк под названием gittyup

Я просто использую Git в Visual studio. Единственное для чего открываю bash это git clean -xfd и сделать очередной ssh. Установлен GitExtensions, но как то не требуется. Пару раз использовал чтобы удалить много веток одновременно.

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

Когда я последний раз проверял Git в Visual studio — он не умел работать с worktree :-(

Вы — не Google kernel.org. Вам не нужно 5 алгоритмических панелей на собеседовании ничего из git, тем более, что Торвальдс сумел сделать его интерфейс полным гуано. Хватит любого DVCS, в котором интерфейс сделан от "что я хочу получить" вместо гитового "как будет выглядеть бинарный дифф состояния репы". Например, mercurial.

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

Профнепригодность, скорее, у Вас, если Вы не можете пострянно обходиться без костылей. git - это довольно простой инструмент, с компактной и логичной моделью работы. Благодаря его распределённости, все нюансы его работы можно освоить на практике (в дополнительных копиях своих репозиториев или вообще на фейковых данных). Простоту освоения git, среди прочего, подтверждает и тот факт, что за последние 10+ лет он стал практически доминирующим VCS, победив и былых гигантов вроде SVN, и всех компетиторов типа HG.

Казалось бы, можно выделить себе время на освоение инструмента, почитать доки, поэкспериментировать, разобраться как что работает. Поднять собственную эффективность в работе с кодом, получать удовольствие от работы. Но нет! Мы вместо этого будем добровольно сидеть в яме страдания, мечтать о несбыточном и ругать Линуса.

Логичный интерфейс, говоришь? Работаю с историей. Хочу откусить и выкинуть два последних коммита в текущей ветке (благо, они только локальные). Может быть, команда будет из серии git log? Нет же, git reset. Очень логичный интерфейс, да. Рассказать, как называется команда для откатывания коммита в mercurial? rollback. Невероятно, тупые питонисты придумали название команды, точно отражающее суть того, что произойдёт с объектной моделью. Не суть бинарного диффа между состояниями репозитория до и после, как в git, а суть понятных человеку изменений.

Ладно, бранчи. Без них же никуда. Тонким слоем по всей системе команд. branch при этом самая малая часть. Что-то в rebase, что-то в pull, что-то в checkout.

Да и вообще, зачем мне эти ваши ребейзы, черрипики, сквоши, прочий хлам? Мне пять коммитов вместо одного глаз не режут. Черрипик я попробовал, спасибо, потом пришлось сносить ветку к чертям и запускать заново, ведь это в гите мерж по сути, взять потом что-то ещё из середины источника в ту же ветку уже не получится. Ребейзы "с красивой историей и подворотами" мне не упали, смержилось — и хорошо. Конечный результат один. А сотен тысяч коммитов, как у Торвальдса, у нас нет, как я уже говорил, вы — не kernel.org. git вам не нужен. Другое дело, что тот же меркуриал медленный, а потому гитхаб столько же одновременных операций с ним, сколько тащит с гитом, не вытянул бы. А у свн проблемы с конкуррентностью. Вот это настоящие причины того, что все сейчас на гите сидят, а не мифическая простота его освоения и использования. Но на селф-хостед гит — это из пушки по воробьям, да ещё и калечить себя его убогим интерфейсом.

Что же до документации. Вот только сегодня смотрел. Что означает git tag -a? Нет, я читал, что в документации написано, что означает "annotated"? И такой магии — полон гит.

Ах да, как в нём сделать шаблон сообщения для тэга? Для коммита есть. Для тэга нет. Л — логика. https://www.selenic.com/mercurial/hgrc.5.html#committemplate Вот, внизу перечень команд, на которые шаблон распространяется. Фактически, все.

В общем, верни собаку.

Раз много коммитов вам не режут глаз, то для отката есть команда с очень говорящим названием git revert. Замечательная команда rollback в mercurial (переписывающая историю) уже давно deprecated, и, внезапно, рекомендованный способ похож на используемый в git

В самых частых сценариях, конечно, не нужны ни rebase, ни cherry-pick, ни squash (я так понял, что вы про interactive rebase). Вы можете их не знать и отлично работать, но я очень рад, что эти инструменты есть. Иногда очень помогают.

cherry-pick вы, похоже, не поняли. К merge он никакого отношения не имеет. В документации самой первой строчкой написано, что он используется для применения изменений из существующего коммита. Как говорится, RTFM

Ещё вы пишете, что документация git вас не устраивает. Но пример, который вы приводите вызывает вопросы. В документации к команде git tag (https://git-scm.com/docs/git-tag) очень понятно описано что такое "annotated" tag в секции Description. Раз вы не читаете документацию (как и в случае с cherry-pick), то никакая документация вам не поможет

Я давно так не смеялся.

RTFM

(c) тот, кто этот самый FM даже не открывал.

Annotated tags are meant for release while lightweight tags are meant for private or temporary object labels. For this reason, some git commands for naming objects (like git describe) will ignore lightweight tags by default.

Hidden text

Это результат следующего:

$ git tag lightweight_tag
$ git tag annotated_tag -a -m "Added annotated tag"

Теперь фокус: что в этой единственной отсылке к annotated tag рассказывает о том, в чём именно состоит эта разница? Ах да:

git describe:
    --tags                use any tag, even unannotated

$ git describe --tags
annotated_tag

Верни собаку, и едем дальше. Черри-пик.

--ff

If the current HEAD is the same as the parent of the cherry-pick’ed commit, then a fast forward to this commit will be performed.

--strategy=

Use the given merge strategy. Should only be used once. See the MERGE STRATEGIES section in git-merge[1] for details.

-X

--strategy-option=

Pass the merge strategy-specific option through to the merge strategy. See git-merge[1] for details.

Ничего не наводит на мысль, что что-то здесь прям слишком сильно торчат уши мержа? Что эта документация нам дала, кроме путаницы?

@KvanTTT

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

Если работа в том и состоит, что откусывать, то да, запоминается. А когда это раз в 5 лет надо -- не запоминается. Более того, а английском языке reset, rollback и revert имеют очень разную смысловую нагрузку. Это в русском "откатить" (новояз) или там "сбросить", "отменить". Reset -- крайне неинтуитивный термин для операции записи истории коммитов (а вот с текущим деревом очень даже подходит). Одна и та же команда reset в гите может:

  • изменить историю

  • сбросить дерево каталогов проекта до состояния, указанного по номеру коммита и/или имени ветки/тега, но не меняя историю

Это очень логично, да. Запоминается сходу.

Вас никто не заставляет их использовать

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

@zloddey

Судя по тому, что Вы постоянно сравниваете "неправильный" git с "правильным" hg, мы имеем место именно с неподходящей моделью

Не надо пытаться подменить обсуждаемую тему тем, чем она не является. По крайней мере, для всех DVCS домен один и тот же. И модель одна и та же: история изменений в дереве каталогов. Просто Торвальдс прикрутил к этой модели интерфейс, пользователь которого в его картине мира является разработчиком git, а потому может по имени git-команды сразу сообразить, какие файлы и каким образом будут изменены в .git. Тогда как разработчики, например, SVN и Mercurial интерфейс пользователя предоставляют такой, который предполагает, что пользователь в том же самом домене и в той же самой модели командует "что я хочу сделать", а что, как и чем поменять в бинарных файлах самой DVCS пользователя не грузят, для этого есть Developer Guide. Как бы это понятнее объяснить...

# Healthy DVCS way
class User:
  def publish_article(self, article):
    article_obj = Article.create(**article)
    ArticleUser.link(article_obj.id, self.id)


# Smoker GIT way
class ArticleUser:
  def create_article_user_link(article, user):
    db.insert(ArticleUser, article.id, user.id)


class Article:
  def create(**kwargs): ...

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

Во втором случае у нас GIT, где пользователь должен точно знать: тут мы создадим объект статьи, там мы должны не забыть дёрнуть метод связывания (иначе статья останется висеть "ничья"). Ну, вы же тут все с кучей кармы, имеете публикации. Вот представьте, что на Хабре надо вместо нажатия кнопки "Опубликовать статью", надо угадать правильно одну из кнопок "Записать в таблицу связей published_objects", "Записать в таблицу objects", "Записать в таблицу posts" (помним же, да, что есть на самом деле "Posts" на Хабре?)

Вы приводите параграф из документации, утверждая, что это единственная отсылка к annotated tag, и упускаете предшедствующий параграф. Он не важен?

Tag objects (created with -a, -s, or -u) are called "annotated" tags; they contain a creation date, the tagger name and e-mail, a tagging message, and an optional GnuPG signature. Whereas a "lightweight" tag is simply a name for an object (usually a commit object).

Игнорируете прямой текст, что annotated tags обычно используются для релизов, а lightweight для временных или личных пометок. Тоже неважен?

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

Не надо пытаться подменить обсуждаемую тему тем, чем она не является

Признаю, в сторону немного ушёл, не специально. Вернёмся лучше к ментальным моделям!

И модель одна и та же: история изменений в дереве каталогов. Просто Торвальдс прикрутил к этой модели интерфейс, пользователь которого в его картине мира является разработчиком git, а потому может по имени git-команды сразу сообразить, какие файлы и каким образом будут изменены в .git. Тогда как разработчики, например, SVN и Mercurial интерфейс пользователя предоставляют такой, который предполагает, что пользователь в том же самом домене и в той же самой модели командует "что я хочу сделать", а что, как и чем поменять в бинарных файлах самой DVCS пользователя не грузят, для этого есть Developer Guide

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

Модели их всё же разные, и оии отличаются в самих своих основах. SVN - это централизованая система контроля версий, Git - распределённая. Уже один этот факт требует отличий в поведении пользователя. В Git я имею полное право не отправлять изменения ни на какой удалённый сервер (и вообще не обязан иметь какой-либо удалённый репозиторий), в SVN я обязан это делать, без вариантов. Поэтому коммит в git - это сохранение локальных изменений, а коммит в SVN - сетевая операция. Из одного этого различия вырастает множество нюансов.

 а что, как и чем поменять в бинарных файлах самой DVCS пользователя не грузят, для этого есть Developer Guide

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

Так или иначе, я не согласен лишь с изначальным тезисом: "полную профнепригодность Торвальдса в разработке сложных пользовательских интерфейсов (даже текстовых) все, включая меня, вынуждены приводить к благопристойному виду с помощью оберток, например, GUI". Модели разных VCS отличаются, и кому-то модель работы git может быть неудобна и непонятна. Это факт. Но:

  1. Она неудобна далеко не всем. Пожалуйста, не надо утверждать за всех вокруг.

  2. Она принципиально познаваема. И для её освоения, честно говоря, не требуется принципиально серьёзных усилий. Хотя негативная реакция из п.1 может мешать этому процессу.

  3. Нужно ли её осваивать? Каждый решает за себя, как я уже писал выше. Плюсы освоения достаточно понятны с рациональной т.з. (можно перестать страдать, можно начать быстрее работать, можно избегать поломок или успешно чинить последствия неудачных действий). Плюсы неосвоения? Отсутствие необходимости перестраивать картину мира. Возможно, что-то ещё.

  4. Человек не всегда мыслит рационально, поэтому для кого-то плюсы неосвоения могут субъективно перевешивать. Но давайте не будем валить всё на Торвальдса, честное слово.

Хочу откусить и выкинуть два последних коммита в текущей ветке (благо, они только локальные). Может быть, команда будет из серии git log? Нет же, git reset.

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

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

Вас никто не заставляет их использовать. Но мне это часто нужно.

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

В своей повседневной работе мы постоянно имеем дело с очень сложными системами: IDE, компиляторами, VCS, ОС, браузерами, сетями, своим собственным разрабатываемым кодом и т.п. (у каждого своё). Ни одну из них невозможно "поместить в голову" целиком, со всеми тонкостями и нюансами. Поэтому мы неосознанно и автоматически используем упрощённые представления об этих системах - их ментальные модели. Хорошая модель позволяет без напряга и с хорошей точностью предсказывать реакцию системы на то или иное внешнее воздействие.

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

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

Судя по тому, что Вы постоянно сравниваете "неправильный" git с "правильным" hg, мы имеем место именно с неподходящей моделью. Подумайте, оправданно ли держаться за неё в 2023 году? Войны DVCS отгремели годы назад, победитель определён, и альтернативные инструменты нужны, разве что, для каких-то узких, нишевых кейсов. Оптимизировать свои модели под широкую область или под нишевую - это и есть тот добровольный выбор, про который я писал выше.

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

тривиальные вещи делаю в sublime merge, это просто быстрее. Нетривиальные - через cli.

Еще пользуюсь lazygit, для случаев когда что-то делаю по ssh.

А где-нибудь есть поддержка worktree, за исключением GitExtensions (хотя и там она ограниченная)?

TortoiseGit не умеет их создавать, но отлично умеет работать с существующими, сам активно их пользую. Под msys2 может не видеть worktree, если путь в служебном файле в каталоге с worktree указан в стиле unix (через /<диск>/<путь>, в таком виде он создаётся консольным git'ом из msys), тогда просто вручную меняем его на путь в стиле Windows (<диск>:\<путь>) и всё работает.

А, ну так IDEA тоже отлично с ними работает, но не умеет создавать. Интересует создание.

Вообще-то SmartGit бесплатен для некоммерческого использования.

Пользуюсь им уже лет 6 и крайне доволен. Пробовал Кракен, Форк, и Саблайм Мерж, но что-то не прикалывают эти Электрон-based приложения своей хипстерностью (знаю, Merge не на Электроне)...

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

Электрон-based

Fork — это .NET-приложение.

Это 2 отдельных приложения на самом деле. Под винду на .NET, под мак на свифте и cocoa.

Если нужно посмотреть коммиты, использую gitg. Чтобы быстро выбрать файлы для коммита, беру tig. Ещё ставил git cola, но запускал только пару раз.

Я недавно искал GIT GUI который бы рисовал ветки так же как люди. Мне для археологии надо. Вот когда вы объясняете branching strategy проекта новичку, нарисуете вы такое же дерево как Fork или SourceTree? Пока что лучший граф я видел у https://github.com/mlange-42/git-igitt . Правда, кроме графа там всё, мягко говоря, скромно.

пользуюсь гитом встроенный в JetBrains. В данный момент, пока еще живое, пользуюсь AppCode.

>подборка популярных решений

>52% используют другой

Как насчёт TortoiseGit? Ну или родного CLI?

Пробовал, честно говоря очень неудобно сделано. Двойные клики по коммитам открывают непонятно что и как вернуться обратно неясно, stage область/рабочая копия и история зачем-то в двух разных окнах показываются, а не в одном графе, как везде в остальных клиентах сделано. Хотя работает вроде бы довольно шустро — пробовал на репозитории с ~300000 коммитов.


Пока наиболее адекватный клиент из бесплатных на Линуксе оказался GitKraken, но памяти он кушает много — на указанном репозитории при глубине графа в 10000 коммитов после открытия 1-2 Гб, а если с рабочей копией активно работать (компилятор в игнорируемых папках внутри нее создает тысячи файлов), то начинает сильно тормозить, может кушать до 12 Гб, да еще и падает из-за нехватки памяти регулярно. Но сразу скажу, что использую я его только чисто чтобы граф смотреть, ресолвить конфликты и делать коммиты (готовить stage, да еще коммитить файлы частично — сделано удобно!). Для ребейзов использую CLI, так как в кракене ребейз медленный и глючный, а еще он на таких объемах репозитория часто падает именно во время ребейза.

Разное пробовал. В итоге GNU/Emacs + Magit, пока не нашел повода менять на другое.

Sign up to leave a comment.

Articles