What about instantly knowing who calls that method or uses that class or that variable, with much more flexibility than just grepping through the code?
Those are the features I use the most in any IDE.
I think IDEs hurt innovation in development tools more than almost anything else. They are like crack for your workflow - easy to get started with, but once you're on them you're stuck. Plugging in better tools into existing IDE is a big PIA if possible at all, and rewriting the whole IDE is a huge undertaking for any company who wants to make your life better.
Standalone utilities generally have poorer UI and require more effort to find and run.
Using vim, emacs and similar always leaves a taste of doing a time travel to the early days of UNIX using text terminals.
Yes. And it has been done. Over and over, each approach crappier than the next.
I'm using Eclipse/CDT; it's really shitty, but sadly still more usable than Vim for large (-ish) projects.
As for finding what calling methods there are, as other have stated, you can use ctags, or go full throttle with Cscope - http://cscope.sourceforge.net/ it will do textual searches along with displaying all callers for a method across all the files you tell it to search (in setup).
With the vim gui and a cscope backend, I'm pretty sure vim is just as much an IDE as any of the other editors. It just happens to work fine in a terminal, too.
<guy never having run more than a mile> 'Yeah I'm pretty sure that these 7.95$ Walmart sneakers are just fine for running the NY marathon, why would I need those Nike's or Asics?'
Neither is better for me than vim and unix tools, even if I have to run under cygwin. It's cool that jetbrains is making something new, I just wanted to point out there are few (if any)features vim and/or emacs do not have.
It also has ctags support so you can navigate your code, go to a method/variable/class name and instantly find out where it was defined and such.
It seems to me that IDEs such as Eclipse, VS etc. are much better suited to large scale development than vim.
For example, recently I worked on the HotSpot JVM, beginning by analysing the codebase. I started with vim and got cscope and related tools working, but they didn't seem to always work, and were much less useful than those I'd used in IDEs. In the end I switched to Eclipse, and was able to carry out the analysis very easily.
One of the Oracle JVM engineers told a friend - they generally use emacs for development, but when someone is trying to get their head around the code, they use an IDE.
So it seems to me that this guy and others "internalize" the way they codebase works, and then subsequently switch back to editors.
Thing is, this all seems rather baffling to me. Surely IDEs are designed to remove a lot of the burden of memorizing syntax, APIs, and the way the codebase works. Intuitively, this sounds like a step forward.
But - lots of experienced and smart programmers still use vim and emacs rather than VS, Eclipse, Qt creator, IntelliJ. Those people know a lot more than me about coding. So there must be a rationale for sticking to text editors.
Can anyone enlighten me please? Should I invest more time in emacs/vim? If yes, why?
Why bother thinking about a clean separation of concerns, isolated modules and good interfaces? The IDE will let me change any method or class name at any time, so I can just use everything everywhere as much as I please. Why bother making minimal well documented interfaces that make sense? I can just make sloppy, huge interfaces with 100s of little functions and use my refactoring and completion tools to find out which ones to call.
I call systems built this way "boogeymen". They are really scary to work on. You're changing some method in some class and you have no idea what will be affected by that method (until you run the system or the tests). You have no idea if that public method is part of an interface to the larger module, or its just public because another class from the same module is using it. Come to think of it, there is no "real" modularity and isolation.
I strongly believe that "necessarily complex system" meme is a myth and complex systems are the result of sloppy work on architecture, modularization and tiny interfaces that make sense. IDEs help perpetuate this sloppiness by helping mitigate the consequences, not by solving the underlying problem