I've tried to migrate to something more lightweight like (neo)?vim, Helix, emacs; but regardless of how good their syntax awareness/LSP support is, it's always inferior to JetBrains IDEs.

Simple example: (any language, e.g. Rust) rename a function across multiple files and undo it. Let me know how you'd do it in your editor of choice.

JetBrains' IDEs are great for the languages which they explicitly support, but are often hilariously bad for the languages that are supported with plugins or extensions. For example, the Clojure plugin for IntelliJ, Cursive, doesn't have great macro support, and, one day just stopped being able to run unit tests. Or rather, it'd pretend to run the tests, give a nice green bar, green checkmark and everything, but the tests wouldn't actually have been run. I found this behavior the hard way, when I almost committed a bug. I'd run the test suite, saw that it was green, and thought that the code I'd written had passed all of the checks. It was only during some happenstance manual testing that I noticed "impossible" behavior (i.e. the code behaving in a way that I'd explicitly checked for in tests). Immediately suspicious, I reran all the tests from a REPL on the command line, and saw a whole bunch of failures that Cursive hadn't reported.

Since then, I've been using CIDER on emacs to do Clojure development, and I haven't had any issues.

Cursive is manufactured by Ideogram Limited, not JetBrains.

That's the go-to example whenever IDEs are discussed on HN but I...almost never do that?

I don't think I can count on two hands the number of times I have to do that in a year. As for undoing it I don't think I've ever done it at all. Anyway it doesn't matter because vim + CoC can do it. And for undoing it I guess I simply rename it back to the original name. Actually I just tried and yeah, it works.

One of these day I'd like to sit with a JetBrains user and see how they work. I'm sure it's a great IDE but so far I haven't heard about anything life changing.

When I used IntelliJ, for the languages it understood best (then Java and Kotlin), it felt very little like editing text. The sense was much more like interacting directly with an AST. I rarely had to use standard 'text' editing features (oriented around word/sentence/para entities). This was an emergent affordance from all the many language-oriented facilities (all available via keyboard shortcuts) offered, rather than one specific feature.

I actually don't use IntelliJ now for reasons not germane here. I'm on neovim, mostly with Rust and javascript/typescript). This is great in many ways but the ergonomics of editing, even with LSP integration, are much more like editing text, which is more distant from my mental model of the code.

I do it all the time. That's the thing, once you can do it without hassle, you do it. Regular scenarios:

1. Refactoring

2. You are experimentally coding and changing names of methods and variables as you realize you need to split stuff up

3. One of your colleagues can't name stuff for shit

The IDE I use makes it so easy it's just a thing I do without even thinking about it.

Another great thing is just highlighting some code and with a simple keypress extracting that code to a new method, with the right return type, params, etc. all done automatically. Not quite right? Highlighted the wrong rows? Press ctrl-z.

This has been my take as well. I can drill-down into third-party packages, rename stuff across files, and use the debugger.

I'm not saying JetBrains isn't fantastic, their products certainly are, but the examples given as to why I should switch are less than convincing. Just use whatever works for you.

It's similar to the flak I get for using an iPhone instead of Android. "You can't customize it!"... I don't want to.. I just want it to make phone calls and browse the web.

Or you don't see the potential, or you're not comfortable, or you don't have energy for this. If you did get the hang of it (vim for example), you would probably use it in some kind of way.

There are definitely two kinds of coders - once that think through everything or at least when it comes to names, method definitions and such they just know what they want. Then there are people like me who is never satisfied with the name or the parameters or the order in which they are passed or the name of the parameters or how the function is structured and want to split it further...etc. So I'm constantly reaching for the refactoring tools of IntelliJ.

OR, as you said, since I have mostly used IDEs all my life, I've learnt to leverage these tools and so I don't always aim to write something to perfection the very first time. Instead I use my IDE as a whiteboard and see where it goes.

Having recently moved from IntelliJ to VS Code, I still miss a few things in the IntelliJ platform (it's overall layout is cleaner, important things are easy to get to), but VSCode has (last I checked) far superior remote debugging support, and is otherwise similar enough once you get past the muscle-memory.

As someone who uses visual studio almost every day I'd say it isn't complete on its own. I can't navigate around a vanilla install that doesn't have visual assist installed as well anymore. If you want a cheaper alternative, workspace whiz is also decent.

Big thing I miss working on VS code and IntelliJ interchangeably. Local history of your changes. Huge differentiator while working on a lot of changes.

I have been using IntelliJ IDEs since the early 2000s. Currently I am using WebStorm's (IntelliJ's small JS brother), and the local history feature in combination with the outstanding diff view are just one reason why I could not work without it.

Local history is a game changer. And live templates. The one I use is using a template to automatically put in console log with the context of where(line num and function name) when I type a shortcut like cl

Go, command line:

  $ gorename -from '"my-package".myFunc' -to myRenamedFunc

I would say that’s a fairly trivial example. How about renaming a method? Or, moving a class to a different file?

Or reordering parameters.

All this fiddling ends when you get a team and a vcs.

gofmt can do that! What I’m still looking for is an easy way to bubble up go contexts, adding as first pagans. Perhaps IntelliJ is useful here?

That's amazing!

yeah, I'm an emacs person and I still use it for a lot of things, but I also am a proud paying customer of the entire Idea suite; I use PyCharm, RubyMine, IntelliJ and DataGrip on a regular basis.

And worth every penny, for me.

sed -i "s/function_name/function_name2/g" $FILES && git restore $FILES

Edit: Not claiming this is better, just saying what I get by with. I have never used an IDE in my career so far, or any autocomplete or code modification features.

It cannot differentiate between a field in a class and a variable in a method, or even a word in a comment, can it?

Sam could do all that since the 80s. So ~40 years.

add the c and it will prompt so you can make the determination yourself.

So, no

People get so hung up on this, but it's literally the shallowest sort of refactoring. If you're choosing your tools strictly for this you're doing yourself a disservice.

It is also the simplest refactoring, and my point is no command line tricks I have can seen can even reliably do this.

Refactoring support in modern IDEs goes far beyond renaming public fields and methods.

I've had this exact conversation so many times over the years.

In truth, you just don't know the tools that well. And that's ok, but as someone who does and regularly does these things in both IDE's and in vim, you're wrong.

But I'm not going to bother trying to convince you, the same way I'm not going to try and convince you that my gf of 11 years is pretty awesome. I don't need you to get better to know that you're wrong.

Good for you. 17 years since I met my gf here.

And I started on vim a long time before IntelliJ :-)

It can with a proper regex. Mostly. Depending on the language, your patience, and the amount of false positives you are comfortable with.

I did sth like that (I had bash scripts for common programming "refactorings" and "queries" like "print all classes and methods where this variable is used"). I couldn't use a modern IDE cause we were programming on a legacy linux server through ssh for licencing reasons.

And the (C++) code was written by a guy that learnt C++ and OOP on the job and it showed. Class hierarchies were sometimes 8 levels deep and class variables were reused for different purposes to "save effort on serializing them" :)

So if the user interactions were in the same order and with the same text prompts - a class would inherit them and add some new ones. Even if the old class was just accidentally asking the user similar questions :) So OR_PalNr could mean shelf number in base class and Printer number in descendant, because both times the user was asked to "scan the barcode", while the callstack was a mix of methods from both classes :)

Fun times.

BTW nowadays I mostly work with IntelliJ, but sometimes a script is still the best way to understand the code. For example grepping the git blame output is often very useful. It's never 100% reliable, but it's often good enough.

First:

> BTW nowadays I mostly work with IntelliJ, but sometimes a script is still the best way to understand the code. For example grepping the git blame output is often very useful. It's never 100% reliable, but it's often good enough.

I see we are on the same page : )

> It can with a proper regex. Mostly. Depending on the language, your patience, and the amount of false positives you are comfortable with.

For everyone else: in any of the three big Java IDEs, and in a number of other cases, you don't need much patience or tolerance for false positives, at least if your code isn't too unreasonable (with any sufficiently expressive language you can of course always fool it by somehow accessing things dynamically).

> I did sth like that (I had bash scripts for common programming "refactorings" and "queries" like "print all classes and methods where this variable is used"). I couldn't use a modern IDE cause we were programming on a legacy linux server through ssh for licencing reasons.

This is awesome!

Sure, but if function_name is a subword of another_function_name, this would break things :/

Why would you want to avoid autocomplete?

And what language do you code in?

Rust in vscode with rust-analyzer: Select the symbol, cmd+shift+p to get the command palette, type rename and select 'rename symbol'. Or right click and pick rename symbol.

You can undo/redo with cmd+z or cmd+shift+z.

replace cmd with ctrl on linux or windows.

F2 is also the shortcut in vscode

Switched this year to VSCode and the quality of most LSPs for VSCode is surprisingly good. Regarding your example: Just rename again. I can tell countless examples of Webstorm failing hard compared to VSCode.

So, from the technical point of view I would say VSCode is equally good.

What I miss most is the UX. Once you get used to the Jetbrains IDEs, their usability is really awesome.

* enter the current and the new names,

* turn on the Match whole word and Match case modes,

* review the found occurrences;

* press the Replace button.

https://www.abareplace.com/blog/blog_rename_method/

Disclaimer: I wrote this program.

First, I almost never do this, so whether I can or not isn't really a selling point. That said, emacs+lsp-mode handles this just fine, at least for c++.

Plus it's awareness of proper idioms in each language and syntax checking makes me much smarter/productive in a new language. Also, it's spell checker keeps me honest. Go for that "green check mark" in the upper right corner and you know you avoided most common mistakes.

“dealing with merge conflicts are a breeze” is an understatement. I don’t use IntelliJ typically in my day to day anymore, but the merge conflict resolution UI offered in IntelliJ is so far and above alternatives that I would still reach for it in a particularly complex scenario. VSCode’s UI does not even remotely approach how good IntelliJ’s is. I’m not aware of any UI that does merge conflicts as well as IntelliJ currently.

P4merge from Perforce works even better. It's just a file merge tool, and doesn't require you to use Perforce.

I've got a git merge/diff wrapper that falls back from p4merge to idea and finally back to stock diff.

To add to the point above, it's worth understanding that IntelliJ is not an editor. It's a refactoring engine with a very nice structured editor, and the key to using it effectively is to use the higher-level features that it provides.

If you're not using the refactoring tooling then you won't understand why many people love it so much.

[It's worth looking under the hood at the plugin APIs. The editor doesn't work on text files. It works on ASTs.]

Agreed. The refactoring tools are something seemingly as simple as rename as variable or method or parameter name to the more exotic "extract constant" or "extract method" or the super helpful redefine method signature (add/remove params). One reason I prefer strongly typed languages like Go/Scala is that refactoring is less guess-work than in something like Javascript or Ruby.

My anecdote is just about the opposite. I was a happy Jetbrains customer for more than 10 years and all was fine (very fine, actually) on Windows for developing Angular on the frontend. Goland is a treasure. Kotlin with IntellliJ can't get any better.

But then I needed proper support for Vue 3, Tailwind and Svelte. VSCode was (is) light-years ahead but what drew me away was how Jetbrains handled the issues. Endless hours writing tickets, creating examples, ... for nothing. Finally, after switching to Linux it turned out that US int. keyboard layouts don't work properly. There's a workaround, but again, the way the support handled the issue was not what I expect from such an expensive service. I was basically told to read through years old long issues to find out how to manually fix it.

That was the day I canceled my subscription.

VSCode is totally up to the job. But somehow I'm still not happy.

Maybe time to try Neovim or Helix (multi LSP needed).

IDEs like this are definitely kludgy and slow but the productivity gain from code navigation, test tool integration, profiler, and debugger is just insane (imo). Having a tool that helps you visualize the code (while it's running) is incredibly powerful

slow? i use both pycharm and webstorm and their are definitely neither kludgy nor slow...

Curious, why not just used IntelliJ with the plugins for python?

I’ve never used the standalone apps. Do they provide a better experience?

Intellij IDEA only has the barest support for C/C++, whereas CLion is a full-featured IDE with similar feature to IDEA.

> I’ve never used the standalone apps. Do they provide a better experience?

In my experience there is no difference in terms of slowness, no. The standalone apps are usually just bundled with more features for the specific use case by default and in some cases they have features you can't readily get in just IDEA.

As far as I know, the standalones seem to work better with SDK and tool detection (I guess IntelliJ has to try to figure out which plugins to activate)

Some projects with mixed languages (like a Ruby backend, HTML/JS webapp) I've had to kick IntelliJ a bit to get it to cooperate and find tests correctly

Someone else mentioned CLion, I think Rider also has features you can't get via plugin (maybe there is no .NET plugin..?)

idk, i just assumed that pycharm would be optimized out of the box for python, so i never bothered with intelliJ

AFAIK IntelliJ with the Python plugin is basically the same as PyCharm.

I think it really depends on the language and project size. Any new project tends to make the IDE barely usable while it's indexing. Compared to, say, vi where everything is instant and there's no visual lag, I'd say it's slow. Even on 16 core CPU with 64GB of RAM and some IntelliJ JVM tuning, I still get some lag/stutter.

My one big complaint with IntelliJ is that they don't have Devcontainer support

It's (almost) 2023, the way to develop applications is to put a reproducible Docker container with all the dependencies + debug tools you need in the repo, so that anyone can clone it and spin it up in their IDE.

VS Code has amazing support for this, while the only Jetbrains IDE that comes close is CLion.

I believe they are currently working with the Docker team on a solution:

https://github.com/docker/dev-environments/issues/70

GoLand and IntelliJ are truly remarkable pieces of software. I try using VSCode with official Go extension every few months and always come back to GoLand.

I love PyCharm for everything but for simple git stuff I somehow always reach for “magit” which is an emacs-based git tool that you can set up as a command you can launch from terminal.

If only it would not gobble up so much memory. For an ide that has been around for this long, one would have assumed they would have switched to a more performant non gc language by now.

Exactly what keeps me away from "J" IDEs and Electron. But if productivity is compelling, I might just consider that my machine is powerful enough and that my daily web browser is just as resource greedy.

I use Visual Studio for the same reason, but might give IntelliJ a try as I've just checked that it also has a plugin for Rust.

Also when you have to refacto in dynamic langages like Ruby, doing merge conflicts, or also anything around a SQL database.

Pycharm for sure.