[reissbaker]

I've used IntelliJ plenty, and it's pretty bad at most of those tasks. Using the git CLI is much better for version control than the Jetbrains GUI wrapper; using Docker itself rather than a wrapper is much better for containers; etc etc. I'm sort of amazed the question of "can you do version control in a terminal" is even being asked... That's where git originated! That's the git team's primary development focus even today!

"Can you run multiple static analyzers simultaneously"... That's sort of the point of *nix systems: multiple processes running simultaneously. Using the shell is of course going to allow that, especially with something like tmux!

Most of the editor questions were also answered by my original post (and the answer was yes).

[29athrowaway]

> Using the git CLI is much better for version control than the Jetbrains GUI wrapper

For some things. But for reviewing activity in git, and tracking changes across time, doing it in the terminal is unproductive and sucks. (e.g.: 10 levels deep of git blame)

> That's sort of the point of *nix systems: multiple processes running simultaneously. Using the shell is of course going to allow that, especially with something like tmux!

I meant getting a consolidated list of from them, and also having the ability to run corrective actions.

> Most of the editor questions were also answered by my original post (and the answer was yes).

Sure, but how much crap do you have to memorize? It's not a unified experience. It's a duct-taped Frankenstein where every subsystem works differently.

[doix]

> For some things. But for reviewing activity in git, and tracking changes across time, doing it in the terminal is unproductive and sucks. (e.g.: 10 levels deep of git blame

The shit I've seen IntelliJ users do in git repos is insane. Somehow they create merge commits between their local branch and the origin version of their branch. They've lost changes, rewritten history, all sorts of shit, with 0 understanding of what or why. I'm guessing the warnings come as a pop-up and people instinctively just click ok without reading.

> Sure, but how much crap do you have to memorize? It's not a unified experience. It's a duct-taped Frankenstein where every subsystem works differently.

From your replies it's pretty obvious you have made up your mind. But what you are describing is my exact experience with JetBrains. The good thing about JetBrains tools is that their language analysis stuff is truly state of the art and significantly better than the equivalent LSP stuff out there. Apart from that everything is a Frankenstein setup that works differently.

In vim, all those plugins are just splits. So I can navigate between them with just ctrl+w->h/j/k/l (most people rebind to ctrl + h/j/kl). Each split supports the vim hotkeys by default, because that is the design of vim.

In intellj it's an incoherent mess. Every pane has some weird fucking hotkey that makes 0 sense. You cannot just go "select the pane on the left). The hotkey is ctrl+shift+alt+7 or something insane, to the point where it's not worth it and you just need to click everything.

[reissbaker]

Sure, but how much crap do you have to memorize? It's not a unified experience. It's a duct-taped Frankenstein where every subsystem works differently.

IDK, my experience with JetBrains is it's leaky abstractions all the way down, outside the core edit/refactor features. Using JetBrains Git without knowing git... I mean, I've seen people do it, but they seem pretty frustrated and confused when things go wrong.

I'd rather just learn the underlying tool once, rather than the underlying tool and also the leaky wrapper around it too.

[viraptor]

> But for reviewing activity in git, and tracking changes across time, doing it in the terminal is unproductive and sucks

tig is great at that. "tig blame" and "," is the way to go for researching the history of some code.

[nequo]

>> Using the git CLI is much better for version control than the Jetbrains GUI wrapper

> For some things. But for reviewing activity in git, and tracking changes across time, doing it in the terminal is unproductive and sucks. (e.g.: 10 levels deep of git blame)

Magit[1] in Emacs is quite okay. It doesn’t feel duct-taped. I haven’t used fugitive[2] in Vim but that’s a thing that exists too.

[1] https://magit.vc/

[2] https://github.com/tpope/vim-fugitive

[alwillis]

Fugitive is legendary for using Git inside of Vim/Neovim.