Hacker News Reader

Comment by Watabou | Hacker News Reader

I love IntelliJ for java development but I never got why I might need a big IDE for c/C++. I just use Vim for that. I mean it does omnicompletion and code correction with clang, has snippets, support for switching between header and source code files.

It works pretty well for me. Even sublime text would do the job since it has all of those features too.

What do IDEs have over Vim in terms of features that I may be missing out on? For java, I would definitely use IntelliJ because of the debugging features alone but I think it's overkill for something like C/C++/Python

View on HN

What about smart refactoring? Being able to rename just about anything (methods, classes, variables, etc...) and knowing that your IDE will do all the right stuff.

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.

Why does it have to be lumped into IDE? Both could be written as standalone utilities that your favorite editor can call.

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.

My IDE has more plugins installed than my web browser!

Standalone utilities generally have poorer UI and require more effort to find and run.

I have been using IDEs since the MS-DOS days and my life is way better with them than without.

Using vim, emacs and similar always leaves a taste of doing a time travel to the early days of UNIX using text terminals.

The core of JetBrains tech is a well built, performant, pluggable foundation that makes them incredibly responsive when it comes to new tools, languages, features, fixes, etc

> Why does it have to be lumped into IDE? Both could be written as standalone utilities that your favorite editor can call.

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.

I rarely refactor across entire projects, but I'm fairly certain vim has plugins that can do that.

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.

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

<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?'

You're assuming I don't ever use one of the other IDE's. I've used Eclipse on occasion (currently using it somewhat on Android development as a debugger) and I have to open up Visual Studio at work on occasion.

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.

I'm pretty sure c++ refactoring is impossible (or near to it) because of the ## concat preprocessor directive.

Not handling ## directive would not be a big loss

Yes it does, because it would refactor partially or brokenly, which is worse in my mind than not refactoring at all.

I'm not really sure what you mean but vim does refactoring just fine with ack/vimgrep with bufdo (applies any vim commands to the current list of buffers)

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.

A full-featured refactoring tool should be smart enough to only rename functions/methods that belong to the same class for example. This is generally possible only when the tool "understands" the language. A search and replaceable can't do this correctly.

This. Vim is great for simple scripts and small projects, but once a project grows beyond a certain size I really prefer an environment with more robust refactoring like Intellij.

I've just vim a bit, but I'm no expert.

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?

I've found that the biggest problem with IDEs is that they let you get away with a sloppy architecture/modularization and having tightly coupled code.

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

On the other hand, IDEs, when used correctly do help with getting better architecture. Refactoring tools and dependency analysis are there for some reason. How often do you get the right architecture the first time? Seriously, I almost always get it wrong and I have to refactor. If there were no easy way to do it, it would just stay like that and technical debt would accumulate up to the point where you'd have sloppy, huge interfaces with 100s of little functions (little functions are in fact OK; huge functions are the real pain).

brilliantly put, just what I think too.

one aspect is speed. every ide i've tried is orders of magnitude slower at startup, and switching from 1 big codebase to another quickly is something I can't do without.

"For java, I would definitely use IntelliJ because of the debugging features alone but I think it's overkill for something like C/C++/Python"

Not sure if you're trolling, but how much C++ do you write? If you have to ask what the difference is between VS and Vim, and are suggesting that writing C++ is more like Python than Java, you haven't used C++ and/or VS much.

(context: I have 10+ years of experience with VS and 15+ with Vim, which is my everyday editor for everything except non-trivial C++ code)

Have you ever used the debugger in Visual Studio? That is THE thing I miss in vim and the likes (yes there's vimgdb ect but that's peanuts in comparision). Combined with the features mentioned by others, that is why poeple want a set of tools that integrate with each other, hence the name, instead of a bunch of standalone tools that also work but don't know enough about each other to seamlessly play together.

Why do so many people seem to miss IDE features when they use something that is so obviously not an IDE?

because other people imply that using vim/emacs with plugin/tools to fill in the gaps is equivelent to using a fullblown IDE, but one that runs faster.

Which is blatantly false.

To me, it seems like a lot of these light-weight Non-IDE text editors, are basically IDEs anyway. You just said sublime and Vim have most of the features of an IDE.

I personally use RubyMine, and while I don't use the debugging a whole lot, it comes in handy with some really confusing issues. Other than that, it is just a fancy text editor that I have become used to for Ruby work.

I love ST3, but there is no true completion, debugger, refactoring, a way to run tests, Git integration...

Even the build system is quite simple...

For ruby stuff, Vim really shines, mainly because of tpope's contribution and his excellent ruby plugins. Along with his Fugitive (https://github.com/tpope/vim-fugitive) plugin, it's actually fun to use Vim for ruby. It's just fantastic. Check out his vim-rails and vim-ruby plugins: https://github.com/tpope

Does your comment suggests that you're using Java for more complex stuff than you would ever use C++?

Not really, I just prefer using lldb/gdb or just simple printf/couts for debugging purposes.

For Java, you really can't get decent code checking with vim unless you use a the eclim plugin and that just feels like a hack.

100% this is my opinion, I learnt C++ using VS and eclipse; I can't remember when or why but I fairly quickly picked up Vim + compiler and it just felt better suited to native development.

Further more the skills feel more real, I can apply my usage of vim and how the tool chain works to other languages.

I love IntelliJ, I sound like I work for them. I don't.... If you do Python web development, specifically Django you can debug your application with that. Never tried straight Python, but probably that too.

Reply on news.ycombinator.com