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++.