I’ve been thinking a lot lately about how I use Git in my day-to-day work, and I’ve realized I still default to the terminal for just about everyth...
For further actions, you may consider blocking this person and/or reporting abuse
I use a GUI (VSCode) to view git history and diffs (including viewing/resolving merge conflicts), but command line for everything else (commit, push, fetch, merge etc) ... just a GUI for tasks which are easier to do via a GUI, and CLI for the rest :)
Just like this, I use the VSCode GUI mostly for merge conflicts and see the branch tree in a much clear way, and have it updated with remote pressing just one button.
For the rest I use the CLI, without any aliases because I like it rough (?)
Yeah VSCode is so good for resolving conflicts! The CLI is just SO much faster for everything else though.
That side by side comparison is too nice to live without!
I do exactly the same!
I learned git via the CLI first, and I have tried using GUIs on multiple occasions, but I'm having a hard time figuring out exactly which commands it's going to run, so I prefer to write it myself 😅
But for git history, and diffs, I use GUIs.
I use
giton the command line 99% of the time.For those hard to reach places via command line, I use either Atlassian Sourcetree or git's own gitk.
My former boss speaks very highly of SmartGit. I haven't tried it, though.
Both Xcode and Visual Studio have git integration, but I never use git from those IDEs.
I've heard from my colleagues that use VS Code that the git integration is excellent.
(I was looking forward to Cycligent Git Tool, but appears to have been abandoned years ago. Alas. It was the one Git GUI client I've found that really resonated with me.)
git in the CLI is slow, inefficient and clunky...
SmartGit is hands down the best crossplatform git GUI I've ever used, too bad they removed the free tier and now its completely payware...
Sourcetree is a bloated mess...
Stay away from Gitkraken, personally I don't trust any app that asks me to login, especially one for git client...
VScode used to have a very popular git extension, that is before it got bought by Gitkraken and now they constantly push you to buy premium or something...
SublimeMerge is a decent git client, could even be considered a good one if it didn't had that annoying popup to buy a license...
Gittyup is free and open source, it doesn't have the most modern UI and it has crashed a few times, but overall it gets the job done, I've been using it ever since I've had to switch from Smartgit...
there are other open source alternatives like Gitnuro which has a modern look but lacks functionality and its development is probably abandoned...
there's also GitButler, another open source with a modern interface that tries to update the workflow of git with virtual branches or something, and it also generates commit messages with AI, it seemed interesting but it feels like its in alpha and in the end I went back to Gittyup...
I will say, I disagree with your first statement. It works much faster than any GUI for larger operations, and if you power yourself with aliases and functions like in my latest blog post you're really speeding up your workflow in the CLI.
Have you checked out LazyGit yet?
I haven't checked it out yet so I don't know what to say about that approach, in general I'm a bit shy of using the terminal so I just prefer clicking on stuff, also having the ability to see a side-by-side code diff is another personal preference
Side by sides are a very nice quality of life feature!
Tools where you can click around are nice, but they're just doing all the commands under the hood for you. So if you're doing some heavy lifting, since the GUI adds a layer of abstraction, certain big operations can take much longer 7-10 minutes in some cases vs 10 seconds or less in terminal. But hey, ain't nothing wrong with a little coffee break now and again!
If you're a little terminal shy, I'd recommend you to follow my channel here. I try and do my best to demystify the terminal and make it approachable for everyone :)
Is gitk available on Linux as a standalone app?
I've not heard of it before though, might want to try it out.
Yes. Actually, it is the GUI tool that I use when the CLI is not enough
I've been hearing lots of good things about LazyGit though!
I've never heard of it being used on Linux, worth checking the package manager for your distro though!
Yes
I mostly use the GitHub Desktop app on Linux/Mac. The thing does have its limits though, so I do have to switch to the terminal every now and then.
I love the GitHub Integration. If my branch is related to a PR, I can see the status of the PR and know out of the desktop app if there's a problem with it or not.
What editor do you use mostly?
I use JetBrains WebStorm mostly. I know they have an amazing Git / VCS integration, but I got used so much to the GitHub Desktop app. I've been playfully mocked by some of my colleagues for being probably the sole developer in our company who uses the Desktop app :D
But like I said - I simply got used to it.
We all fall into ways. I would encourage you to play around and learn Idea VCS. It's literally better than everything else. I think you'll find the swap easier than you think!
The only beef I have with GitHub Desktop is that I only can have one stash active in the UI. I'll try it out and see how it works! The good part is - I have used it to some extent already. I know that changing branches also kind of restores the branch's "workspace", which is a nice feature. This of course gets lost if you change the branch from an outside source.
One feature that's pretty nice is you can create different groups for your commits. So sometimes code bases suck and you need to have changes to make things work and not want to push them up. So you can create a group called "don't commit" and move in the files you don't want to commit. then you can have them seperate from all your other changes making it really easy not to accidently push changes you don't want to commit.
The merge conflict editor and diff tool are out of this work imo too. :)
I use a bit of many things:
gitkmost of the times I want/need to look at the history, andgit citool(fromgit-gui) to stage changes and commitgit mergetoolwith Meld to resolve conflictsI think it varies person to person.
Most def does! However, I've definitely seen some trends on this thread. I think the most common answer I've read so far is, "Yes, I use the terminal for most things but I use VSCode or Idea VCS to handles conflicts and diffs, since the GUI makes those more easily readable with the side by side comparisons"
I use the command line, gitk, and lazygit for their respective strengths.
Lazygit can do things like move a commit back in history, which is just a little easier than command line interactive rebase. It can split up an old commit “in place”, which is also an interactive rebase which contains more steps. It can edit commit messages in old commits, which is helpful when you’re the maintainer of a code base with commit message standards. Basically, I use it to do commit cleanup before and after the pull requests. It’s very helpful for rebasing and conflict resolution too, where it shows you what commit you’re currently merging and which files are in conflict. And it allows you to view the conflicts and open an editor to work on that file. After you fix and save all the conflicts, it will continue merging the next commit until done.
Gitk is useful for its lazy graphical UI updating. When I press F5, it refreshes the branch and tag states but still keeps the old refs. So if I made a mistake in the current session, I can just hard rebase back to the previous history. Lazygit will prune the old refs from the view aggressively.
The command line is good for git status and quick commits, as well as times when you want to pass in —no-verify or other flags.
I used to use tig (git spelled backwards). It’s now replaced largely by lazygit except for the use of git blame. It can traverse history to find who really created the line, even after it’s been reformatted by other people. It’s not automated but the tool makes it easier.
I use the git provided by VSCode and git graph to have a clear visual.
I'm the lazy person that do not like to remember git command and prioritize speed/ minimal steps or keystroke to achieve what I needed to, most of the time when I work with build-in git it's usually the case of me waiting for tasks to finish, instead of tasks waiting for me to finish typing.
I love the little time where I can squeeze in a little bit of stuff.
GitHub for PRs. git CLI for everything else. However, like just about everyone else, I have my own wrappers and environment based on a separate branch for each development project or production triage event, a work tree for each branch and a framework that keeps track of it all. For the interested see my ‘personal’ repo under ‘matthewpersico’ at github.
And emacs is my IDE😉
OMG YOU DON'T USE VIM?!?!?! Haha jk, even Neovim is trying to pull a lot of things from emacs. Emacs can technically do more than you can in Vim or Neovim. I've tried SpaceMacs before and really liked it!
Thanks for sharing! 🔥
I moved away from the CLI and use GUI tools now.
I started off with SourceTree by Atlassian. It was great. But it was a super memory hogger and CPU hogger.
Then I found GitKraken. It was cross platform - supported in Windows, Mac, Linux. But somehow the UI didn't quite cut it for me # felt clunky and slow in rendering all UI components.
Then I found Fork and been madly loving it since 2019. Very feature rich. Does not hurt CPU/Memory. The UI feels snappy and it just works. Their team is also pushing out new features and bugfixes quite fast compared to other publishers. Only downside, is it is only supported in Windows & Mac. So if you're using Linux/Ubuntu, this is not for you. But i have been a super fan of it on MacOS ever since - and later learned that many of my colleagues switched to it as well after they saw me juggling with it.
The support for Git in VSCode works for some. But to me, using it feels more like a second-class citizen - an after thought experience - because it tries to fit itself within the UI framework of what was originally designed for VSCode. An advantage of it is that it's free. But if you have the licensing budget, go for a tool which is a first-class citizen and purpose-built specifically for the job of being a git UI.
I think Fork is the second favorite tool that's been suggested! (That I didn't know about before) This seems really cool. The first for me is LazyGit because I'm a terminal junky XD But I think I will be suggesting Fork to plenty of people moving forward :)
I must admit it was a small bouquet I used, a combination of the terminal, vscode extension and GitHub Desktop. Some steps along the way just seemed more comfortable here and others there. However, for anything complex it was definitely the cli.
For personal projects I generally use Git For Windows as it usually suits my needs. I only use terminals at work where we need specific flows/rebases and it's important that other developers see the flow they expect.
I use magit, the emacs package, most of the time. One step up from the command line.
I do use the command line when there's nothing to edit.
Tools or CLI? It doesn't matter that much in my opinion. The basic advantages and challenges stay the same (merge/rebase conflicts, unexpected "detached head" out of sync states), and why isn't anybody mentioning the elephant in the room? GitHub / GitLab or whatever central authoritative hub repository brings back many of the problems we had when using SVN, and why is GitHub so prone to time out over slow networks? They really introduce an unnecessary single point of failure to what was designed as a robust decentral successor to SVN.
GitHub has quite a few problems. It's so trendy. I prefer GitLab personally.
Resolving merge conflicts and if I only want to commit part of a file, then intellij still saves the day. Those probably can be resolved with better workflow and smaller commits.
But otherwise, nothing beats the speed of command line. It never lacks.
Most of the time I use the CLI: it is simple (once you learn it, but I did), fast, you can get old commands with Ctrl-R, and so on and so forth. I guess more or less everyone here knows the advantages of CLI.
I must also say that usually I do not feel the necessity of something graphical; however, every now and the the necessity arises (for example, to have an overview of the "history" of the current branch) and then I typically use gitk which is enough for my needs. Every now and then I tried other tools, but I do not feel the need to replace gitk.
There are def some niche cases when a GUI is nice. I love those side by side comparisons!
GUI tools are nice for visualization, but you can really get yourself twisted up in the axles by pressing buttons for git functionalities you don't truly understand.
The CLI requires a certain level of proper syntax/relevant flags knowledge which act as a set of safety rails preventing a rank neophyte from force-pushing an ill-advised rebase they just initiated by face-rolling the keyboard a moment ago.
However, beware the junior dev with just enough CLI knowledge to be truly dangerous!
I use a GUI for certain things, but for the basic workflow of fetching, pulling, rebasing, and committing, I use the terminal. I just use whichever tool I feel is most efficient.
For viewing commit history and diffs, I usually prefer to go online to Github or Gitlab and look there.
When I have a ton of old branches lying around and want to figure out which ones I don't need anymore and delete them, I like to use the VS Code GUI for that.
Still?
I never stopped!
I really struggle with GUIs. There are only a few applications where I've put in enough hours to find them comfortable.
I feel this way too. Even with databases. I learned the how to check/change things from CLI and everyone was like, "you should use this PSQL GUI". Then I open up the GUI and I'm like, "How do I do the things I already know how to do???" Lol
I was using the terminal for a good amount of time but realized the GUI works better for me in most cases and the reason is I want to closely monitor my code and the changes that I've made and with GUI tools, there is better code readability. (diffs)
But for normal and common actions, I still use terminal and I guess this hybrid combination is the best way for me.
This is the most common response for sure! I have a hybrid approach as well. As long as there's something to get a nice view of conflicts and diffs I'm set!
I mainly code on windows and use a very specific workflow.
I always clone on the command line, but that's pretty much it.
I nearly always use TortoiseGit to commit and push.
And I use Fork (a wonderful gui for wi'dows and mac, but sadly not linux) for everything else.
I know it's kind of weird, but this is how I'm productive with git!
In my case, the entire team uses gitkraken, except for me who still uses the terminal. I have Gitlens configured in VS code that belongs to gitkraken but I don't use it. I've always felt more comfortable working with commands through the terminal. I simply find it easier to understand and organize my ideas and actions. Many times, using applications with GUI I end up getting lost between options and tabs. It's a bummer for me
I think Git integration in GUI/IDEs is great and can even be handy for shortening the distance to good commits and playing nice with others. However, if you are in a position of doing any kind of build management, integrations, deployments, managing CI/CD, &c &c &c, having a really solid handle on Git is essential (assuming that's your VCS, of course!). That doesn't necessarily require the CLI, but keeping those manpages handy certainly does keep the options in mind for the inevitable code untangling that those disciplines regularly encounter! In my own experience, working with Git primarily or exclusively from the command line drastically shortens the distance to automated solutions and a faster pipeline!
Yeah! When the IDE i'm using has a nice tool to compare conflicts and diffs that could be nice! But for all the other operations, I'm in the terminal. Thinking of checking out LazyGit for comparisons when I'm working in Neovim.
Yes and no... I used git inside of PhpStorm for work and in the CLI for my personal projects. It's easier to use in a GUI but forcing myself to do it manually sometimes ensures that I remember the commands and know how it works.
IDEA VCS is 🔥 Big things are faster in terminal, but if you do those big operations with a GUI you can take a coffee break XD
I've always used git in the terminal. I was burned a while ago with a desktop app that completely borked the repo. It destroyed the ref log, and all my work was gone. Because of that I stay in the terminal
Wow! That'd keep me in the terminal too!
gitbash (on windows) or simply git cli on Linux or nothing!
IDE/OS agnostic.
Oh, well, not quite I guess. I'll use intellij's merge tools for performing merge conflict tasks and sometimes for diffing file versions, but for the most part the CLI.
I use the command line along with gitui a text-based UI that runs in my terminal. I use that for most simple things like staging, committing, pushing and viewing logs. It lets me save keystrokes without having to go with a full GUI client as I find them overwhelmingly complex. For more complex things like rebasing, cherry-picking, etc. I use the command line. I keep two Powershell windows open in my Windows Terminal, both targeting my repo folder. One has gitui running and the other for straight command line Git. I have POSHGit installed and that provides some assistance like tab completion.
Vscode works fine for git, but it kinda sucks. The only way it's tolerable is with gitlens. But lately I find that vscode's git UI is unbearably slow. Often it doesn't even update with changes until I click refresh. Git over terminal is the only true reliable way
Try LazyGit! Looks cool :) Idea has the best vcs imo
Yes I do. Most of the time. Why?
I’m far to be an expert of Git command, and CLI is a nice way to improve and learn daily.
I use some text expansion macro to build branch names from bug id.
So it’s often faster for me to just type « gco -b ,/bug » and boom I get a new branch and can commit my fix.
I tend to work mostly between IntelliJ and VS Code. So I do not want to depend on a specific IDE integration.
I tend to also use Git Tortoise on Windows and Source Tree on my Mac. Just because I’m fine with them
There a lot of value to diversify the ways you use a tool. Don’t put yourself in silos.
Jetbrains is my favorite git GUI ever. They should honestly make their own stand alone git client and they'd crush the competition imo
Totally agreed. They have the best set of predefined commands (until I came across Lazygit). The 3 way diff merge is the best and it was there from a time when no one was providing such an easy merge view. I old stopped using jetbrains because of the heavy resource usage on systems.
I've been wanting a git tool that does 3 collum conflicts like the other tools. Can't wait to try it!
gcb is even shorter for "gco -b" if you're using the git plugin for oh-my-zsh.
oh-my-zsh is 🐐
I have tried GUI like git tower and intellij plugin, but never get used to it. The git cli give me control and confidence about what I am doing, I have no clue how to manage a
rebase -iusing GUISo I’m happier and more productive on command line
EDIT: typos everywhere 🤦♂️
I think I am just so used to using GIT in the terminal that I almost unconsciously use it there. VSCode's Source Control tab has some nice and welcome feature, but as I said kinda got used to the terminal. Also, when working on remote servers you don't have the GUI option anyways. So, terminal is go to for me.
I use the VS code git tab for things like controlling which file changes are included in a commit and adding a message to the commit. But i still use the terminal for switching between branches and creating branches and cherry picking commits and stashing changes and viewing the git history logs.
I use LazyGit in the terminal with LazyVim
I love the LazyStack!
Yes! "This is the way!"
😎
VS Code UI generally, Sometimes I use terminal also cause it's fun. 😅
Terminal! It's probably just because I haven't taken the time to properly learn them, but whenever I use a gui I always end up getting frustrated by some unexpected behavior.
It’s a mix, I use the UI for committing and diffs, but terminal for most everything else.
I think this is the most common answer for sure!
I mostly use GitHub Desktop, and a little bit of Magit. I'm also interested in what the folks at GitButler are doing.
I use Fork. Because another big clients is just a trash on js ui frameworks. They use to many pc resourses
Fork looks really cool!
I only use git in terminal
Agree with others here. I still use GIT 99% from the command line even though I might occasionally allow VSCODE to manage my updates.
Yes, I still use git in the terminal! It just makes me more confident to not mess things up.
The only thing I use VS Code for is resolving merge conflicts.
Cli for most commands. Sometimes I might use a GUI to view conflicts.
Same! 💯
I always liked to use the terminal, there's an amount of dopamine gained for knowing the git subcommands and resolving all problems without the clicking in a GUI.
I agree! 💯
Being familiar with the terminal is a skill you will appreciate eventually.
💯
have been 7 years we are forced to use gitk.. since company is not allowing to install any additional "bloating software".. and its lightweight though
Are they a Linux company? Or government?
Git documentation is based on the terminal, so that’s what I use.
I use VSCode for commits because I'm editing anyways. It's just a couple of extra mouse clicks.
I use the CLI for most everything else.
I do a bit of managing on the GitHub website.
I use Lazygit, is a TUI for git that enables me to use git without going out of nvim. It has a cool visual cherry pick that is nice.
Am about to add this to my Neovim flow :)
I think Intellij is great, you don't need to type git commands, can use ui features for almost all commands,for example ctrl+k for commit, you can see text box for the commit message
Git Extensions is one love. Especially for repo and team review with kdiff3 and difftastic integration.
Unfortunately there is no version on Linux...
😭 Looks like LazyGit is pretty 🔥 though!
I use intelij webstorm for 3 way merge during conflicts. Outside of that, always git cli, with delta-diff.
yep
yes i normally use it in the vs code terminal
I use mostly terminal, and if I need to view branches/changes with it content I use gitk.
Probably one more case of using UI is git blame, this I run from IDE.
I've never used git from the command line, but I've also always worked in small teams of two/three developers and our repository has never been much more than a backup with benefits.
Yeah, on big projects when you do something crazy heavy once in a blue moon, the GUI can take several minutes where as the command line would do the same in several seconds. But hey, good excuse for a coffee break! ;)
Command line all day.
That said, I learned programming on a SPARC station, so......
Thanks. Git Kraken looks cool.
Most of the time I spend with git is in a Terminal but diffing and staging mostly in the IDE. VS Code is great for merge conflicts too, but even with the good UX I feel like GUI haven't gotten it perfect yet and most commands can be issued in the Terminal.
tigis a good upgrade forgitin the Terminal too.Yeah, merge conflicts and comparing digs can be really nice in a GUI. I think Jetbrains has the best GUI git integration ever imo. VS Code seems very solid too!
If you don't want to leave the terminal, I would suggest trying the merge conflict resolution of Lazygit. I have started liking it but I still feel during complex merges the 3 way diff of jetbrains is unbeatable.
This is 10000% on my todo list!
Lazygit and Tig seem to have some overlap, but it's possible Lazygit could be more intuitive. Giving it a look. Thank you!
on Windows I use GitHub Desktop app it is faster then what they embedded in VS Code.
Your commits and pushes transfer much faster and it has direct linking to Github, VS Code or File Explorer, at a click away.
I also still use Notepad++ when I am pondering something deep. I use the terminal to run the server and pass to Github thru the Desktop app.
FYI: GitHub Desktop works really well both on Linux and Mac! Personally, I have used it on Ubuntu because there is an easy-to-install .deb package available. For Mac you just download and install the .dmg file.
I have Ubuntu-22.40.xx-LTS on here thru WSL and have had Notepad++ installed / added it to the variables beside nano.
That was awhile back when you could only embed Firefox for a browser. Plus jump thru hoops to configure a GUI and file system - explorer based root directory.
I have used it on Ubuntu because there is an easy-to-install .deb package available.<
I will look for this package as I am getting back into MongoDB and like to use it for the web backend and node / express server stuff. As well as VS Codes terminal or Windows cmd. I was bottle feed on Windows 7 .... that was my first ever intro to a computer. I have only used Windows machines for coding and not developed anything on Mac or I O/S anything.
Back when Swift was just introduced I was learning Unity and Android / Gradle. Just because it was like $60 a month to get permission basicly to build for Mac - I O/S.
That is what I was told ... $60 a month to Publish your code and you need Pro version ANYTHING they make to develop or preview your code. That was 2015 - 2016~ish ....... way back then!!
Regardless if you were certified dev's or first semester. Google is $25 for a one time developers registration free to Play Store. Android Studio is free and has all build tools the way Visual Studio Community Edition does.
I am only focusing on browser - HTML - CSS - JavaScript as it is all you need to become cross-platform ready.
Learn Docker and enjoy writting code today. Instead of what you had to plow thru 10 years ago to get a page to mobile or desktop. What you don't have to do anymore, many people today have no clue. I got my first computer in 2012 and was playing with dev tools console by 2013.
What they had to work with was called bower and brocolli ..as package managers and basic version controlling. Gulp and Grunt were just introduced people still though Ruby was the only was out. And jQuery and PHP were NEEDED to get hired.
As Angular and React were designs stills and Gadspy and Webpack were being rolled out. NODE and npm were being built as well as bable for future es6 ... From a computer science eyeball the modern web landscape has evolved drasticlly. From 2000 with Push Notifactions and Paggers to the 2010 APP for that explosion. To say the least .........
I grew up when they just started allowing calculators in the class rooms for tests and finals. We had a bunch of "OLDSCHOOL" teachers that made you take out the batteries if you put it on the desk!! So I learned it is bested to focus on two ways to do something. In case one fails !!
Seems I lied a bit about the .deb package, sorry I misremembered it :D
There is a package feed you add, and then simply run
apt install github-desktop. Here's the docs:github.com/shiftkey/desktop?tab=re...
Same here for a long time, but then the last two years I got a new job where they were strongly suggesting I take a MacBook because it will be easier. It's a great product and I enjoy it a lot. I can definitely see the appeal in it.
Then I also dual-booted Ubuntu on my existing Windows PC and that's where I do most of my work now when I work from home. You don't have to go all-in on the Linux-ness and build your own OS or try arch-linux (even though I want to do that too at some point). Ubuntu gives a great out-of-the-box experience and the last few years has been very stable and consistent in many aspects. I can't recommend it enough.
I know what you mean about the industry changing rapidly. I've been a developer for over a decade now. I remember OC'ing my Pentium 2 processor from 200 to 300 MHz and frying it in the process. The first OS I used was Windows 3.1. Now I have a Watch on my wrist which is more powerful than my fried Pentium 2.
They never let you do it the easy way. As someone who has trained a few developers I can see why that's important. You can of course complete the task faster, but you're missing out on the underlying mechanics of things.
I was learning Drafting and Mechanical Drawing in 1978 from a teacher who was one of the draftsmen who layout the B-17s for Boeing in WWII .....
In 2013 -2014 I was using NERBS in RHINO design software and SketchUp & Blender as substitutudes for CAD and AutoDesk - AutoCAD .........
I have lived and loved in both analog and digital worlds and for all those who were born after Y2K. It was said to be the end of the world as we know it !!!
...... as 2020 and life after Trump have shown it just took 20 ++ years to take effect!! ..... Peace and enjoy the ride I was chasing the Web from 2013 till 2019.
I am glad I jumped onboard and went the route I did. I was told learn React for one year and half and thats all you needed or learn Wordpress & Bootstrapes.
I love to learn and enjoy the struggles it brings -- LIVING / GROWING from 1964 to 1999 and no internet and 4 to 6 weeks for delivery was spot-on!! We have been given a golden advantage over many today. And we Gen-X'ers are gone ..OH BOY !!
... most don't exert anything extra to anything. Social Status and a fake profile or brand and more income then your neighbors is the chase.
Rolling up your sleeves and getting dirty has so much value. Def a quality that seems to be loosing on the most recent generations. But I have hope things will start to turn around. :)
the ones in charge have already figured it out ...... more like know that only 10% of the 5 million programmers they needed yearly are worth it.
I recommend this as a must watch and share as to anyone who wants a back ground in code today.
He rocks ..... if you can stand him !! ~:// https://www.youtube.com/watch?v=ecIWPzGEbFc&t=1508s
"Uncle" Bob Martin - "The Future of Programming"
With AI taking the basics out of the way, they now only need 5% of that 10% for IT and in house proprietary designs.
So pick your poison and become a computer programmer with a CS degree.
Or become a Web Developer - Designer and help create cool sh^t and a new genre in thinking and learning.
Got a cool idea myself and was told if you think like Tesla or Steve Jobs remember Big ideas have big failures in order to be worth a sh^t ...... Don't be afraid to fail as a way to grow
also if anyone wanted to read Turing's explained paper. This is the PDF of Petzold's break down.
github.com/pengbo-learn/books/blob...
For me personally, using
gitin the terminal is a 100% better than using vscode, vscode offers only limited utilities than using git in the terminal.And for those beginners who are reading this article, I highly recommend trying Git Exercises for those who are starting out.
Wow! Super cool resource! Will share this with my friends :)
I use my IDE to handle git related stuff. intellij has a good integration with git log, rebase, commit, stash, revert etc.
No reason to bother with knowing commands by heart, I'm using hotkeys to switch and compare branches as needed.
Idea has best git GUI imo!
I do. Even though I spend most of my time in VS Code, I eschew its terminal and git integration for a dedicated terminal (iTerm). I find it much faster to cmd-tab (I'm on a Mac) to switch to my terminal and issue commands.
Control + ~puts you directly into the VSC terminal when your current context is VSC. Bonus,Command + ~switches between instances of the same application, these commands are very helpful when you have two or three instances of VSC open all with their own terminal.Thanks for the short cuts! Super useful :)
I added this to by bashrc a long time ago. since then I have been using them generally. Might be useful....
Love these! Bash functions are so great when doing stuff like that from the command line!
GUI tools are like drawing things to communicate with other people: Great for when you don't share a common language, or to occasionally illustrate things that are just better understood visually than in text.
But when both parties speak the same language, aka. the git command line, then it is quicker and more effective to just use that as the main form of communication.
I almost exclusively use git from the command line, and when I need some graphic stuff, just opening github/gitlab/forgejo is usually more convenient than having a dedicated local tool for it.
Other than that, I have a vim script to
diffa file against its committed version to easily see what I've changed, but that's about it.I know Jetbrains has a super cool diff feature in there VC. Saved my butt at work a few times!
Yes, I basically just use Git in the terminal, and on some occasions, I use gitu tui.
To help me with Git in the terminal, I have some aliases, and I use meteor to help with commits! :)
Wow, nice! I've been looking for some good terminal tools for git! XD I'm thinking about writing an intermediate to advance git blog, and I'd like to tie in a bash article after it showing off some fun Git things you can do. But I was wondering if people even do stuff in the terminal like that.
From all the responses on this post, it seems like it's a good idea to go ahead and write them up! Haha
Yeah,
gituis such a cool tool!You should totally write that blog post, I’d love to check it out and learn more about Git!
A lot of people work with Git in the terminal, so I’m sure your tips would be super helpful. :)
Go for it! Can’t wait to see what you share. 😊
I'll have to check it out! 🙂
Yes and no, but it depends.
I usually use git pull to pull a repo regardless of ide. I sometimes prefer doing commits in the terminal for multi-line commit messages, since VSCode limits my commit length otherwise.
I often use the GUI tools from VSCode for my Git usage, but at times find it helpful to use the cli, and in some cases that's all I have.
I want to setup LazyGit and use that, but haven't looked into it just yet. It looks like an interesting tool.
LazyGit is awesome 💯, it gives you the option to use the git commands you never knew you wanted without having to memorize them commands and parameters.
For beginners it makes git lot easier and allows you to know what git commands it executed, has increased my knowledge of Git more than when I was using direct git command line only.
I plan on checking out LazyGit soon!
I think having relatively short commits is best practice. But they still shouldn't force it down your throat
I almost always use the CLI. I have plenty of custom git aliases too.
Aliases help me squash, save, making features branches and even clean up my local branches that have been merged.
I use VIM bindings so my fingers rarely leave the keyboard anyways. A quick CTRL+SHIFT+T and
git wipautomatically saves my progress.I love VIM :) Stared this gist. Will check out adding some of these to my list of aliases :)
Terminal is very flexible and customisable and suitable not only for git, but for many more things. For example, I use terminal for Git, Code search (find, grep).
GUIs are usually tailored for specific use case and might be limiting.
I agree! It can be nice for viewing difs and conflicts at times, but most of the time the terminal is fast and easy. Especially when you have your own alias and functions to help speed things up!
Exactly!
That's funny, we were just taking about this. "Annotate" in VS on our "worst" file was minutes, for me about 7 minutes, to complete. Command line
git blamewas 10 seconds, maybe. Probably less. I don't know what VS is doing that took it so long with this admittedly desperately in need of refactor file, but something is off.That's always the trade off when relying on tools that abstract thing away.
I used to rely heavily on Git commands before switching to Visual Studio Code, except when working with Xcode. Now, I've fully transitioned to using the UI for most operations. The UI provides a clearer view, especially when resolving merge conflicts. However, I still prefer using Git commands for basic tasks. For example, I continue to use the
git clonecommand to clone repositories, helping me stay familiar with Git commands.This is a super common approach. Conflicts and diffs it's so nice to have that side by side view! I've experienced and others as well, when dealing with a massive amount of changes, the GUI's can get pretty slow compared to the terminal. But for most basic operations, if it's build into the IDE, it's pretty convenient!
I have always been amused with some of my teammates using VS Code to search for specific patterns in their code. Why not use
grep -rin your cloned project? And I keep saying: “You guys tend to do simple things using least efficient methods”I'm a terminal junkie myself, but so many people are afraid of it! I try and write blog posts to help people become less afraid.
I let my IDE do the very basic stuff these days. The cli is for heavy lifting though. You can really ruin your day with a slightly bodged git command…. (and then you’ll be fixing it manually with git’s reflog anyway).
You bring up a good point!
I usually use GIT from the IDEs itself like VSCode and PyCharm The most.
But when creating repos I use the terminal, dont know why? (Maybe I just love to copy paste the commands GitHub gives for the Initial Commit 🤣)
There's just something really nice about being in the terminal. You don't need an excuse :)
Yes. Part of it for me is cross platform consistency. Command line git is the same for me in Linux, Windows and OS-X. Maybe there are also cross platform GUI git tools, but most GUI tools I have tried feel like I am wandering around lost trying to find the three command line operations I use all the time.
Also, when I need to do something unusual, the help on Google for command line is much more abundant, and correct, than GUI git wrapper guides. Then there's scripting...
Mostly I arrow up in the terminal to get the last time I used a command, then edit it if necessary. Tends to be quicker for me than GUI interfaces, even when they are integrated in my IDE. Having said that, when I add a set of new files through the IDE and it asks "add these new files to git?" I will, usually, say yes instead of doing the command line add.
The terminal is universal :)
Git in the Terminal day to day. If I need to do a complicated merge or feels lazy and want some auto-merge capabilities I use Fork. An amazing cross platform git GUI client that is free for evaluation and is developed by a husband and wife team. I've used Gitkraken in the past but given it was free then became a paid tool I dropped it quickly as I don't believe Git clients or tools should cost anything.
Very nice! I will have to check this out :)
I use git mostly on the command line.
This may be due to my lack of knowledge of other git commads.
I mostly use the commands such as clone, push, pull, branch, add, commit, stash.
To be honest till now in my learning phase i never had an instance where i required more than the above cmds.
I don’t think of git GUIs as a replacement. But they still have a valuable use case.
The git CLI has a ton of features and I don’t know of any GUI that supports every feature. But in my opinion git CLI has a bad UX that makes it easy to make very big mistakes.
For example git merge doesn’t tell you which branch you currently have checked out. You have to remember to check that yourself. And even if you check it, you don’t have a guarantee that another terminal window didn’t change it after you checked.
GUIs can tell you you’re currently checked out branch and auto update the value.
That’s just one of many examples of where a GUI can prevent you from making silly mistakes.
And anytime that you need to dip into something more advanced, you always have the option of using the command line.
Do you use zsh/oh-my-zsh? My terminal has the current branch next to my username a file path. Really handy!
Well, i think GUI or CLI are both good, the important thing is that we know how to take advantage of the benefits that both of these methods bring. GUI is not only easy to access for beginners but also extremely convenient to replace simple use cases. Not only that, but when interacting with a lot of information, using GUI also helps simplify the process and limit the risk that can occur due to typing mistakes. Meanwhile, CLI can be used almost anywhere, easily included in automation processes, and provides advanced power without the limitations of GUI managers.
Advice for beginners: Choose to use convenient GUI tools that log syntax, every time you perform operations on the interface, follow the log to grasp the CLI commands, you will gradually understand more deeply how this tool works, as well as improve your git CLI skills.
I maintain an open source project (github.com/enciv) I use git on the command line 100% of the time because it's too hard to explain to new devs how to do things with a gui. Part of making open source work is having documentation the makes it easy to get started and contribute. Documenting guis is hard to do and hard to follow. Also, after your fingers know the commands it's way faster than doing it through a gui. But I do use VSC and a plugin for doing different between branches.
I agree with this. Anytime I help someone with, the terminal is universal!
I prefer to use both terminal and GUI. The usecase defines the tool. Basically for any preview related usecase, I resort to UI.
Before commit, I review the changes in Sublime Merge. And remove the debug logs using unstage line feature.
For viewing file history along with preview, Sublime Merge serves the purpose.
For all the other cases, I'd use terminal and use in combination with scripts or git aliases.
Sublime was my first editor :)
For sometime now, I seem to have stopped using git in terminal since the introduction of no support for password authentication in Git.
SSH is a thing for me though but since VS Code comes shipped with tunnelling, it kinda make the workflow simplified for me hence my reason of not being worried for too much about my non usage of git in the terminal.
Albeit, I'd love to explore other options mentioned in this post, thanks for sharing .
I cannot live without magit/edamagit. I have not found anything nearly as good for creating nicely curated history. Staging chunk-by-chunk and effortlessly rebasing are magical.
edamagit vscode page
Looks very cool! 😎
I don't quite understand the phrase "switched to using a tool". A shell running in a terminal is a tool. In many cases, and at least 90% of the time with git, it is the best tool. Use the tool that works best for you.
I don't mean that the terminal is or isn't a tool. If git is installed on a unix-like system, then the terminal is the default way to interact with it. People build GUI tools to make the process simpler and more visual. That's what I mean.
I'm currently using git through VSCODE with Git Graph, most of my commits are made through the VSCODE Git tab, but I always push or pull through the terminal, however 100% of the times When I need to merge two branches I use the hit graph, especially when I want to get a specific commit, it is much less work . I don't see a problem in using GUIs, I just don't recommend it when the person is learning git, to learn and understand in my opinion it should be through Terminal
I agree with this! 💯
So ive been a GitKraken user and advocate for the last 6 years. I can hanlde myself on the occassions i have to use the CLI, but IMO outside of basic git commands, GUI igenerally provides a better experience. Ive seen first hand that jr devs have limited understanding of the git commands. They know enough to scrape by (push, fetch, stash, commit, new branch), but tney have had an existential crisis when asked to cherry pick, resolvr merge conflicts, view diffs, view commit history, rebase, revert a commit. I think having the jr devs focus their time and effort on solving bugs, tickets, and adding features is better than looking down on them because you are a Git CLI "purist" and they need to memorize git commands.
If you have an arguement of having to do some git gymnastics through ssh on an AWS EC2 instance, then i would argue you could have mitigated that "locally" to spare the headache on a remote vm.
Also, im a visual learner and having the GUI pefrorm my git task and even showing me the commands i would have used in the terminal has made me have a much deepet understanding and appreciation of the git cli.
Sorry for the rant!!! Much love to all devs honestly.
There's nothing wrong with that! Git can tie you up sometimes!
Most of the day-to-day stuff is done via the source control view in VSCode. Context switches KILL me, and since I live in VSCode, it’s just so easy. For more esoteric things (figuring out how a junior broke their repo, etc) I’ll drop to the terminal.
I'm a father of 3 young daughters. I know what you mean about the context switching XD
Sure, don't want to depend on any GUI, tools. It makes me passive when moving out of other workspace or environment.
I used git everyday through IntelliJ for 6 years... Then it suddenly struck me, I didn't actually know how git works and I was fairly lost in the terminal apart from the very basic add and commit. I decided to read GitPro (great book) and then forced myself to learn how things work under the hood, and therefore, use git in the terminal. It's been such a pleasure working with since.
What an awesome story! I love that. What a great way to stick it through 😎
I'm still a super novice but, my professor encourages us to learn git through the terminal. He also advocates for Linux and has us use the terminal for pretty much anything. I still have a lot to learn about git but, I enjoy using the command line so far.
Being comfortable with Linux and the command line will only bring you the best fruit! Seems like me and your professor would get along!
I use the CLI most of the time. In my opinion, CLI skills are transferable - it doesn't matter which job you have, what code you're writing, or even which OS you're using, the commands are the same. But GUIs may have slightly different methods of doing things, and may not be available everywhere.
There are use cases where a GUI is preferable, and I do use it sometimes (e.g. 3-way merges, log visualization). But I don't see it as essential to my work.
With that said - use whatever tool you're comfortable with, and don't overthink it ;-)
I agree 💯 %
In addition to
gitI also use the TUI tooltigwith a bunch of mappings.I've heard good things about tig!
Now I use the awesome LazyGit for accessing git from command-line, works like a charm. (Best for Cross-platform development too👌🏽)
While doing .net based development for apps I use Visual Studio built in Git client.
Also I use Notepad++ built in Git client for browsing source tree when need a particular change history.
Earlier used Git command-line but after Lazy git got lazy.
Been hearing so many good things about LazyGit! I'm going to have to check it out 🙂
I use a combination. Whenever I want to just unstage and I am not sure of the command I am thinking of is going to simply unstage or just destroy all my uncommitted changes, I find the clearly labeled 'unstage' button useful. Otherwise, for fetch, rebase, branch, switch, pull, push, stash etc everything on the terminal.
Yeah, so roughly, terminal for going forward and gui for going backward.
I like that approach! I think most people have a fragmented approach, including myself :)
I've been using Git mostly from the terminal, most of the time. When I was using windows, I used to use a tool called Fork, very neat UI and at that time VS code internal git was quite bad. But then I kept going back to the terminal, I've now settled on Lazygit, it's a TUI, so no more extra heavy application running that goggles resources, very powerful and precise, has a lot of functionality and makes tedious commands easier like moving a commit 2 places ahead because improper rebase created a merge commit, or things like updating an old commit with extra code easily with 2 key combination, etc. After finding this, I've been using it for more than a year now.
I started out with a GIT GUI but struggled! Then I flipped over to Terminal and never looked back. It was faster to learn the concepts initially by having direct control. But I do understand why people would prefer the GUI environment!
Anytime I can use the terminal, I default to it!
A vast majority of the time I will use the CLI. It's where I first learned git, so I think I have a natural affinity to it.
If I'm using a UI:
Honorable mention: tig. It's a git tui, probably more terse than lazygit, but it introduced me to staging lines and chunks. I wound up using lazygit because it's easier to teach to other team members and simple commit reordering and fixups are really nice in lazygit.
I'm going to check out LazyGit very soon!
I used to have the same viewpoint as you but the intellij/phpstorm git gui has really been an awesome example of how great they can be when designed right. With Ai commit messages, I'm actually adding some really helpful info for myself and other team members without a thought. Historically my commit messages have been trash.
Idea should turn their source control into it's own stand alone program. It's the best in my opinion. I use it for work all the time for conflicts and diffs. The diff tool is so powerful. Will be trying LazyGit for my personal work
I think I am in a similar situation. I can't let any GUI take control with the fear and anxiety that it may end up doing something I didn't intend to. Plus, git commands are simple and straightforward for the most part. The responses and error messages are clear enough
I feel you! I think most people fear the inverse of making a mistake in the terminal and not being able to or knowing how to walk it back, so they rely on the version control GUI's to help them handle it.
It depends on what i wanna do.
Simple basic stuff can be easily found in IDE integrations so when i'm satisfied with how the IDE presents the feature, I may use it.
For more specific commands or settings (git log -S, git config, etc.) it's not negotiable: terminal4tw.
I'm using free version of "Fork" as GUI for 3-4 years now and i have to say that i really like the view of the tree, specific actions are quite easy to find, diff-tool is also great.
I'm really considering taking a completely optional licence to thank the dev.
I find the JetBrains product integration frightening: i'm quite lost in it when i give it a try sometimes 😅.
VS Code's seems the same to me: too many things hidden or not well placed that it lets a meeeh feeling. I'm sure a lot of people have come to master those integrations but i switch back every time to terminal when using those IDEs. 👍
Jetbrains is my favorite! Once you get it, it's super easy and all kinds of cool features :)
I use Sourcetree for simple commits, visualizing the history, and launching bash; the issue is that it doesn't support some common parts of my workflow.
Libgit2 is used by nearly all git GUIs and it doesn't support moving the core worktree at all, which is mandatory for one of my use cases to the point you can't even use a GUI to commit. I also add other worktrees to compare old versions of binaries in proprietary editors and that process is not in most GUIs either.
Terminal is old faithful! Have you looked at LazyGit? Been hearing lots of good things!
I use both with similar frequency and often in combination. For instance, I'll start an interactive rebase in the terminal then use the GitLens GUI to pick, squash and move commits around.
Git is such a pervasive tool in our IDEs these days that even a command line purest can't ignore the benefits of GUI elements like inline git blame.
I agree with this! There some features that just work better in a GUI
I still use git at the command line even though I develop using IntelliJ IDEA. Alas, it's hard break from what works.
Idea is phenomenal at merge conflicts and comparing diff's :)
Yes. I do take advantage of what's better as GUI that way although, for a quick diff, I'm still at the command line.
Love it!
Unless I am using windows which I rarely do anymore, I would use the website, but on linux I just use
gitas it just seems easier that way, but I am migrating from the site.Linux is life! No windows for me. Work forces me to use a Mac because I'm a mobile engineer and Apple is evil. I think I like Microsoft more than Apple, but that's not saying a lot
Yes, still 100% cmd line usage just like I'm still 100% manual docker commands because I like to know exactly what is happening and what I'm doing without abstraction and potentially unwittingly performing actions to some hidden GUI defaults (at least I can look through the man pages for the defaults for a command).
I've already done the GUI to cmd move being an ex-Windows to a Linux/Unix professional so I have a certain perspective when it comes to GUI vs cmd.
I only do Docker from command line. I'm in love with Dockers networking capabilities.
I’m the same way—I still prefer the terminal for Git commands! There's something about the control and direct feedback that keeps me hooked. I’ve tried GUIs like GitKraken and SourceTree, but I always come back to the terminal. That said, VS Code’s Git integration is handy for quick visual checks. What about you?
Jetbrains and Neovim are my favorite IDE's. I love checking conflicts and diffs in Jetbrains IDE.
There's a feature to create different groups for staged changes in the commit tab that's been wildly useful at work when I want to make sure I don't accidentally push up changes I don't want to. Terminal for everything else :)
Terminal... And because i'm using zsh and auto-complete, I can reuse easily my history so by just type a very few letters, hop I retrieve my previous commands.
Zsh is my favorite shell!
yes i also still i do git on terminal. i use small alias for a log with graph and oneline.
Love writing aliases and functions to speed up my workflow!
switch to warp. A terminal that has AI inbuilt
Ya I'm still primarily using the terminal but I also use Git Tower for browsing specific commit diffs
Having a GUI to deal with diff's and merge conflicts can be really helpful. By far the most handy feature from GUI's. I also think that GUI's can be nice if you need to organize your changes into multiple commits.
I really enjoy the merge conflict interface right in vs code personally
still use git in terminal even though so many tools out here like lazygit, gitkraken, vscode buildin git integration.
I am a QA engineer and mostly only touch my test code so I just use the built-in visual studio GUI, but if I am doing personal work and deploying code I use the terminal.
Basically yes, but I also use lazygit. It has undo.
Yes, and I'm building my own terminal interface to git, which is currently a prototype in my dotfiles. The only things I use a UI for is resolving merge commits and exploring history with blame.
Also, I use git-revise and git-interactive-rebase-editor as some really handy commit reordering / slicing / cleaning tools.
I'll have to check these out!
I love it when I see people build their own tools! Keep working on it! 🔥
I use git from the terminal and when I'm coding (PhpStorm, PyCharm, Visual Studio) I use the built-in VCS tools, but installing a dedicated application just for doing git stuff just feels wrong for me :)
No one beats Idea version control GUI imo! ❤️
I I use GitHub desktop
yeah for me i have had the best experience with git using the terminal
Unpopular opinion: CLI proficiency isn't getting set in your ways, it's how you level up 😁
💯❤️
Lazygit in the terminal, sublime merge otherwise.
Merge has saved me so much time!
Im using Github desktop
Jetbrains inbuilt git tool.
My favorite!
100% git in terminal all the time. I always want complete control over the commands. I do not like 'black boxes' that hide the control from me.
Yeah! Better to build a good understanding from the start! Black boxes can bite you
I use command line and git-fork.com. Among other features Fork is great at visualizing merge conflicts
Wow! Looks really cool. Love the UI
I think we just to use the terminal.
I only use it from the command line personally. I can't stand the GUI interfaces.
I use the command line most of the time, as UI tools like those in Github and VS Code are useful in some cases...but they oversimplify in too many cases
Being able to see a side by side is OP!
Yes 99% of the time
I left the CLI and have been using GitKraken for years. I still fall back to the CLI maybe 1% of the time if I need to do something more advanced (like bisecting or anything with the ref log)
My good friend loves GitKraken!
Terminal is faster. And for any complicated rewriting of history, it's the only way to do it well.
Terminal is 👑
I still git in the command line, feels easier than clicking around.
But maybe you are right that is just the power of habits
I love the command line. The more you keep you hands on the keyboard, the better imo!
I use JetBrains IDEs built-in git client for pulling, pushing, committing, switching branches. For more complicated things I prefer Git Extensions
Jetbrains version control tool is on steroids!
I only know the basics of git and I only need the terminal for what I've done so far. I think as I grow I'll probably continue to use the terminal for everything that I am able to.
This is, in my opinion, the best way to start!
Using **Sourcetree **for more than two years and as usual via the command line also.
Hybrid is probably the most effective approach. Having a good display for conflicts and diff's is really nice!
Git GUIs are pointless. CLIs only
Now that's what I'm talking about! 💪
I use lazygit and it's custom commands. It's simply amazing 😍
Can't wait to try it soooon!! :D
GitKraken
My best friend loves GitKraken!
Yes I do, and I like it. However, I have also used the VS Code integration and will use any other as long as I achieve the goal am after in the most efficient way.
Seems like a fragmented approach is the most useful for the majority of people I'm seeing in my comments!
I use git from the command line most of the time. I only use a GUI during resolving rebase (merge) issues. For that, I use p4merge
Conflicts and merges are very nice in a GUI :)
I always use git in command line. I feel like if i know how to use git in CLI i will always be able to use git irrespective of which IDE i am forced to use.
This is very true!
Cli baby . Only way to go
✊
I use JetBrains' tool only to review changes, but stash, pop, commit, push, pull, rebase, create new branches, fork, cherry pick, tig, all on the terminal.
I think looking at conflicts and diffs is really where the GUI shines. Jetbrains GUI is very polished on those things. I love using it when I'm not swimming around in Neovim! Haha
almost ...
Terminal is the way to go for me
I tend to use BOTH. For example for some matters such as rebasing with or without interactive. I normally start it in the CLI, if there are conflicts I might resolve then in a IDE.
When you're working in an IDE that has good version control, doing certain things with that GUI really helps speed up conflicts and looking at diffs!
I use GitKraken 98% of the time. It's great
I have a good friend who loves GitKraken :)
Github Desktop - Clean and easy to use interface - Rebasing Cherry picking, Comparing branches, History, Everything is perfect for me,
My experience with GitHub desktop wasn't that great but I know others who swear by it. :)
I used to use GUIs for git, but at some point decided to learn how git actually works and now I just use it in the terminal. Much safer imho when you know what you're actually doing.
have you tried oh my zsh? I switched from Bash several months ago,
It's got some sweet Git shortcuts built in. It might be a nice middle ground if you're not ready to go full GUI.
Oh yeah! Oh my zsh is great! Love it :)
yeah sometimes.
I always use the terminal for initialization and first commits, after that I use VS Code's source control sidebar.
GUI's make certain aspects better for sure!
of course
Only ever use git in a shell. I spend 70% of my time in the CLI anyway, so nothing else really makes sense.
My colleagues all use UIs for Git. I use terminal 100%. The UIs are buggy as Hell and have caused major issues. The terminal never does that.
The terminal is old faithful!
Yes, command line. I don't even use a GUI, but screen on a terminal.
Love it!
I use SmartGit for a few years now.
It used to have an evaluation (free) version, but not anymore. Even though it costs money I stayed with it, which I believe speaks volumes about it.
Yeah! I would say so. My buddy pays for git Kracken. Once you find a tool you love to use, I think paying for it is a great way to support the developers! ❤️
Yes, I switched. Used terminal for years and liked it. But I like the overview on branches and tags I have in the client. I feel it as a slightly improved usability
I agree with this!
I use git command line for most things except for commits and for merge conflict resolution. For that I use the git interface in Intellij
Yeah, I think those situations is there the GUI shines best!
VSCode Merge tool then terminal for everything else. Though as I am 'the developer team' I rarely have more than one feature branch, which I avoid if I possibly can.
Well that both makes things easier and more difficult! 😅 On one hand, you don't have to ask questions about conflicts! 🤪
Yes, for the regular git operations I still prefer command line for the sense of predictability. For the git diff view, I do use VS Code or visual studio.
I'm pretty similar! It's nice having side by side comparisons:)
Everyday. It "just works". And that's enough for me.
You're a much luckier man than I! XD
Yes I’m always on git terminal writing commands daily… guess I’ll give lazygit a try.
Heard lots of good things about LazyGit! Will be trying for myself soon!
I was using the command line almost exclusively until maybe a year/year and half ago.
Now when I do small changes I tend to stage from the editor (neovim+lazyvim) and if I need to browse things I use lazygit, but for "important" commits where I had to do a lot of back and forth to understand how things need to work I still use the command line, often with
git add -pto keep the changes logical orderI use git in the terminal, associated with github.com/tj/git-extras and am super happy with it.
The few times I tried a gui, I always finished messing up my repo because the gui didn't do what I expected. Therefore, CLI all the way for me !
Absolutely! I totally understand people who use a GUI but I don't really have a problem with the CLI, so there's no reason for me to change. The only times that I've seriously considered using a GUI tools are the times that I've completely messed up my repo.
Only for simple actions like switching branches, checking out code, browsing the commit log, etc. For more advanced actions like interactive rebase I prefer to use vscode's git integration (with the GitLens extension). This combo is most efficient to me.
I typically work with a variety of tools. Sometimes I use VS Code, and other times I use JetBrains. Lately, I've been using LazyGit as my Git tool, but when I'm in a hurry, I prefer using Git directly in the terminal because it's simpler. I try different tools since I work with VS Code, IntelliJ IDEA Community, and nvim.
In the end, I believe you should use the tool you feel most comfortable with. If working in the terminal is what suits you best, then that's what you should use.
I too use git on the command line. The few times I have used a GUI, I find myself thinking of any actions that I take in terms of what the equivalent commands are.
Perhaps it's just me and how I understand using git, but I feel like understanding what git does is better understood from the CLI.
Maybe I just haven't used the right GUI, but to me they have felt like a secondary tool -- something that distances me from what is important rather than enabling me in some way to get the job done faster, with more accurate results, or presenting information in a more understandable way.
Take for instance, navigating routes you know well vs. using a map or GPS navigation. If you know the routes well, you know how and why they get you where you are going. If traffic or construction presents you with problems, you can adjust and still get where you are going and you are less likely to make a wrong turn. The same can be said for maps and GPS, but the tool contains the intrinsic knowledge of where you are going and how to get there. You are at the mercy of the accuracy of its data and its interpretation of it. This is not a perfect analogy, but I think it gets the point across about how using GUI git tools have felt -- like using GPS navigation with out of date data or overly complex directions.
Yes, I use command line. However, I created duke-git -- An open source wrapper shell scripts for git commands.
I find them more intuitive and easy to use. It is not exhaustive but is sufficient for my daily work.
I always use it on the command line. I tried a few times on intellij and pycharm, but I cannot figure out how it works on UI. The only thing I figured out is to 'pull changes' to the current branch
Nothing better than the terminal. :-D
I must use git on vscode terminal 80% of the time. But I use vscode git integration for merge conflict resolution
Yes, the terminal is my IDE and my favourite TUI for Git is Lazygit.