I understand speed - I use vim for quick edits/changes - but simply being able to jump to the source of a function you're looking at is huge (yes I know about ctags for vim - doesn't even feel like it comes close).

EDIT: One of the other huge benefits of IDEs in general is working with and studying code that you didn't write yourself. All the sublime and textmate fans I know are almost always just writing their own code from scratch, or using a small subset of well-known plugins for popular framework X. Taking code written by someone you didn't know, who perhaps didn't even know language foo very well, is a pain that is lessened somewhat by using a capable IDE vs a plain text editor.

Emacs + Slime for Common Lisp programming is often held up as an example of this. It provides all the features you mentioned + more. Slime (or rather Swank and alternatives that have been made) has been used for other languages as well: Clojure, JavaScript, Haskell, Ruby, R.

If you work in more than one language then Emacs and Vim quickly start to look enticing since most IDEs either don't support them or don't support them well.

That said, I have no opinion on IntelliJ. I have never used it, but it sure sounds like I should try it out sometime. The last IDE I used was XCode one year ago and Eclipse a couple of years ago and they didn't make me very happy.

edit: My point is, people often hold up both Emacs and Vim as "just text editors" but coupled with a Unix environment and the right programming languages (not Java) they provide a lot of features that IDEs do. Besides that one can use these editors for a lot of other editing tasks like writing manuscripts, e-mail, blogs, etc. giving you the same powerful editing functionality for those tasks.

People saying this have never really spend much time with a modern IDE.

It's like having Vim newbies saying it's too difficult and they prefer Pico, only in this case it's the IDE that's the more advanced.

I'm working on a personal project in my spare time which I can use it on. (Except the project is using Common Lisp so it might not be a good match.)

I forgot to mention in my original post that I've also spent time with Unity3D recently although for some reason I didn't think of it when thinking of IDEs I had used in the past.

Emacs out of the box (install ruby-mode) is not even close to RubyMine. Now, if I spend many hours, and I value my time a great deal, I can get emacs kinda close to the features of intellij.

Frankly, I'd rather pay $60/year than spend many hours trying to get emacs close to as good as RubyMine.

When in Java, there is a mishmash of supporting file types, and it integrates them very well compared to its competitors - jump between .java, .jsp, various .xml for Spring, Hibernate, tag libs, etc etc. If you are "just" programming in a programming language (which is a lost utopia in for J*EE developers), much of this functionality is not of much benefit to you, but you might still find the IDE valuable.

Yes, it's quite good. Visual Studio is also very good in some aspects. And you can also get a lot of mileage out of Eclipse. Also try some Smalltalk environment, you'd be surprised.

The thing is, there are things missing from Vim/Emacs that are not easily added as ad-hoc plugins. Not merely this or that feature: what is mostly missing is a coherence in supporting a specific language.

And once you get ReSharper, also from JetBrains, Visual Studio becomes quite good, too :)

I would hands down pick the right language for a project and then the editor.

(I am actually a Vi guy, but switch to an IDE for any project that involves more than just me)

I used to adore Emacs in college, but since I've actually had to work on large projects I would never switch back to using except for when I need to bang out a python or shell script.

I've used various versions of emacs over the years for most of my programming (mostly C/C++ with some sprinkling of python and java). I've recently had to use Eclipse for Android dev. I agree that it'd be almost impossible to integrate the entire GUI dev framework of Eclipse Android environment in emacs (not to mention continuous compiles and other java-firic features) and that's the reason I use Eclipse for Android. But "Jump to Source" ? Emacs is a far better and faster experience for me when it comes to trolling around in big, unfamiliar code-bases. The small subtle lags with eclipse (it's not as bad now with my monster new dev machine with 16G of ram) still irritate me. And the Emacs keybindings are almost there but not quite.. which is another big reason I've resisted IDE's. They're just slower for actual editing of code. Always. Without fail.

Regarding ctags, it's useful enough, but it doesn't do a great job of things like jumping to the definition of the "flags" part of "p->flags", if you've got lots of structs that have a "flags" in them. Same goes for member functions. It's absolutely no fun trying to find out what something is, and just getting a list of every single thing of that name in your program. Thanks ctags... but I actually know how to use grep. And if I used grep, I'd get a callers list too.

I found ctags workable, but overall disappointing.

Are you referring to this line:

"The fuzzy parser supports C, but is flexible enough to be useful for C++ and Java"

I think you might be misinterpreting the wording there. It's called "c"scope because it was initially written for C and C only. The line above is suggesting that it also has support for C++ and Java (because it has a "fuzzy" parser... whatever that means).

May clang cause people to expect more from their tools.

Also, I found it really slowed things down (in RubyMine), sometimes updating just 1-2 characters a second in a big project (on a modern MBP).

I've gone back and forth, but generally I prefer Vim with Janus distro, albeit I miss a lot of cool things from IDEA.

I just upgraded from a "modern" macbook pro (2008, aftermarket SSD) to a "modern" retina macbook pro that is maxed out. IntelliJ and RubyMine fly like the wind on this new machine. The old one was painful to use IntelliJ but you could live with RubyMine performance.

They've found a good tool, emacs or vim, and want to use it everywhere. They've invested time and effort into being productive with it. Moving to an IDE requires time and effort as well. IntelliJ and the family are deceptively simple. You can start editing right away, but to enjoy the full power, you need to learn it. Just like vim or emacs.

[1] http://visualstudiogallery.msdn.microsoft.com/59ca71b3-a4a3-...

However, there is still an unacceptable delay between typing and feedback, around 300ms.

Performance was clearly not a priority for them.

I want a good IDE, but none of them are good.

http://blog.jetbrains.com/webide/2012/08/liveedit-plugin-fea...

I think Emacs will get a big resurgence if they ever get a better Lisp (aka Guile) integrated so they can get better performance. After all, Emacs is just a big Lisp interpreter. In theory, Emacs can do anything.

Using an IDE took your coding to a next level just as design patterns took your coding to a next level because, by using Java (or C#), you need to automate and repeat tasks that should never have been mandatory to repeat in the first place.

To me nothing beats a programmable "text editor".

I don't doubt you consider yourself "productive". However Rich Hickey created Clojure using Emacs and then, using Clojure, he created Datomic. That's certainly something I'd call productive. So there's not one true way or true light to see to "take coding to next level".

It's good for you if you like your Java/C+ + ORM ([N]Hibernate) + XML + SQL hell. I don't like that particular hell which I know all too well and, thankfully, many programmers don't like either and are, productively, creating a better world for us programmers.

I still did buy IntelliJ IDEA version 12 during their doosmday promotion because at 55 Euros or so I figured out it was going to be handy the day I'll be forced to work on some pathetic Java / Hibernate / XML / SQL hell codebase but, thankfully, I still didn't need to install it (it's only two months but still...).

Meanwhile Emacs / elisp / Clojure are getting their daily dose of love.

Your Mileage May Vary but I honestly think you don't realize that most of the tasks IntelliJ allows you to automate are tasks which shouldn't exist in the first place.

P.S: it's possible to configure vi(m) and Emacs using eclim / emacs-eclim so that you can use, right from vim/emacs many of the features of Eclipse (like auto-completion). This is something with may see more in the future and that we may see working with IntelliJ too.

So I guess the information below will rock your world and change your editor of preference:

"I developed Clojure in IntelliJ and still do (the Java part)."

http://markmail.org/message/pon2e77mdtkath26

IntelliJ is a productive tool, and it is interesting that Rich sometimes uses it. BTW, I do about75% of my Clojure development work in IntelliJ and about 25% with Emacs and nRepl. I find IntelliJ just a little more productive, but both are great working environments.

I also work in a number of non-JVM languages in Emacs, and have used it for quite a long time. For JVM work, IntelliJ is, as you say, 'a little more productive'.

There are pros and cons with Java, but if that's what the application is written in, then I'd much rather use IntelliJ than Emacs/Vim. The reason is that a lot of the coding is navigating the code base - finding out what the arguments of a method are, or finding out all the usages of a class/method/variable. This is much quicker in IntelliJ than in a generic editor.

Another argument I hear a lot against IDEs in general (although not from you) is that they force you to click the menues a lot. Not true. There are great built-in keyboard short-cuts, and of course you can create your own, so there is not a lot of reasons to touch the mouse.

Edit: A post by him http://markmail.org/message/pon2e77mdtkath26

Thanks Jetbrains, for a great IDE!

p.s.: the discount (of all jetbrains products!) was around december 21st.

I almost did the same thing you did during the sale but one of my friends let me know about the plugins, which they could do a better job of talking about.

Can't go wrong with this great software either way though.

My primary Java IDE had been NetBeans for years, mostly because the rough edges in Eclipse outweighed the extra functionality.

Recently I've been doing some Android programming, and found the native lib support in nbandroid to be suboptimal at best.

Idea works swimmingly in the same situation, and Eclipse well enough, so my options were to muddle along with manual build system changes in NB, add necessary functionality to NBAndroid, or switch.

Since I spend a huge chunk of my time coding C (NB's C support is actually quite nice), I've been giving Eclipse a go. It's come along rather well, I must say.

That said, if Idea were to add official C & C++ support, I'd be on it like white on rice. I very much prefer to use one primary tool, minimizing switching back and forth, so using Idea for some languages & platforms and NB or Eclipse for others just isn't palatable. Idea is almost good enough to make me consider a two IDE world, though (this from a "vim unless I'm doing Java" guy, up until a few months ago).

Sadly, I've run into an aspect of CDT that might be enough to push me back to NetBeans, even if it means doing some additional work. It seems that CDT language aware search (such as "find references") takes pre-processor directives into account.

So, when searching for, say, a function name (or worse, doing a "rename" refactoring), I'll only find a subset of occurrences, depending upon what symbols I have defined for a given build configuration. For personal code, that may not be an issue, as I tend to eschew ifdefs in favor of using different implementation files resolved by platform specific make targets.

However, the main code bases I work with daily are littered with #ifdef WIN32 and #ifdef TRACE_ON and such.

The difference between using a real IDE and an editor with hacked IDE extensions is like the difference between hunting with a rifle and hunting with a bow and arrow. If you're skilled enough, both will work. If you're set in your ways you may prefer the bow, and the bow offers a more primal experience and requires more dedication. The bow is certainly more badass. But the rifle just boosts your productivity immensely.

The one downside of IDEs is that they can encourage a bit of sloppiness. The tool automates so much you want it to automate it all, but there is still no substitute for a good working memory and careful study and thought.

FWIW, I just discovered VIM Adventures a week or so ago, and I'm planning to try to give it a chance to win me over:

http://vim-adventures.com/

My only experience with IntelliJ is with a job I quit within a month because they were using some boring proprietary Java framework that has almost no documentation. I have no qualms about IntelliJ, I think it's pretty, looks a lot like NetBeans, but I don't think I've fully maximized its features (heck, I can only say it's pretty). I also hear a lot of people say that IntelliJ is the best IDE for Java. What makes it so much better than Eclipse, and maybe even NetBeans?

Eclipse has historically suffered from a couple of major problems, in my opinion:

1. It's "Eclipse is a framework, and the Java IDE is just an implementation" mentality made the user experience terrible. Everything was a perspective, with it's own configuration. I remember distinctly trying to set the editor to use four spaces instead of tabs. I had to do this once for every file type (xml, javascript, html, java, css, etc.) Commands would suddenly be disabled because you were looking at a file in a different perspective. In all fairness, the usability of Eclipse is getting better, but this, to me, is still Eclipse's major weakness.

2. Their JavaScript (and other language support) was terrible. (Note: It's first-class now. But it took a very long time to get to this point.) For those of us who did a lot of front-end work, this was a major shortcoming.

Overall, Eclipse has gotten much better, and there are some plugins that just might make it your editor of choice. IntelliJ is still my choice, though.

For Eclipse, you had to rely on 3rd party developers for plugins for things like Hibernate or Spring integration; and the amount of integration with the IDE itself was usually hit-or-miss. Different plugins would have different UIs or different ways of doing things.

I've found that in IntelliJ, these types of things are first-class features instead - the Spring and Hibernate support (for instance) is built into the IDE by JetBrains. Things like "find usages of bean" can be invoked with the same keystrokes as "find usage of class". The editor can jump from the Java class editor to where the class is defined in your Spring context just as easily.

I would say try IntelliJ for a month. That will give you time to alter some of the strange default settings (like being able to put the cursor past the end of the line) and discover some of the many other powerful features (like clever renaming of getters/setters when renaming a field). But I still believe it is the speed that sets IntelliJ apart from any other IDE out there and will be the ultimate reason for your improved productivity.

(personally I use eclipse and take the time to babysit it because I can't live without proper incremental compilation)

In my last job where we used Eclipse, we'd get a maven project and then run mvn eclipse:eclipse to generate the eclipse project. In IntelliJ, you can just open an existing maven project by selecting the pom.

Maven auto-update is also nice (if you do a mvn clean install, your project will automatically update accordingly).

In eclipse, if you debugged into an external library, you'd have the option of attaching the source; then you'd have to go find the right jar to add. In intellij, you can just click "download sources" and it usually does the right thing.

In general, I had a fair amount of difficulty setting up projects and getting them to run correctly under eclipse -- but that may be more of a reflection of how our projects were configured. Things seem smoother under IntelliJ.

Source: 5 years with Eclipse, and 6 months using IntelliJ 11/12 now.

Rest I can't comment on how good they are with enhancing your productivity, as I never used them.

However, it is really hard to beat free. I think the numbers show that 7 of 8 Java developers use Eclipse. This also means that third party providers are more likely to build on top of Eclipse.

The fact that IntelliJ has built a large user base only goes to show how good a product they are.

Yeah, IntelliJ has recently launched an open source version... But I am a little reluctant to use it given the strong Ecosystem around Eclipse.

(Disclaimer: I build plugins for Eclipse)

Having done Android work in both Eclipse and IntelliJ, I much prefer the latter. It has nice tools out-of-the-box for every aspect of Android development; package signing (and keystore management), integrated logcat monitor (a bit simpler than Eclipse's), the on-device or emulator debugging works perfectly etc. I've never had a problem translating Eclipse tutorials to IntelliJ.

It's also a lot less buggy than Eclipse+ADT in my experience. Eclipse/ADT is terrible when it comes to larger Android projects that may reference other projects in your workspace, I frequently had to do a clean build to get it to detect changes across the projects (a known problem in the ADT bugtracker IIRC).

IntelliJ is also faster, has better code completion, and a really nice dark UI theme called Darcula out of the box (trying to make Eclipse dark is near impossible). It's paid for its price many times over in productivity gains for me.

Can't give you a comparison because I use it infrequently, and I use IntelliJ for Ruby. It's a lot more polished than Aptana Studios' Ruby integration, which is basically Eclipse.

On the NetBeans subject: does NetBeans have much traction outside of Sun/Oracle? It's been a while since I've done any Java development, but back in 2005, it seemed that pretty much only the official Java tutorials used NetBeans.

I've been using that ever since and almost never use ST2 anymore (I really miss multiple-cursors, so I still use it for that).

PhpStorm gives me so much more information about the code, such as validating types (based on type hinting), showing warnings when the wrong type is used, automatically updates DocBlocks with correct information, allows very fast jumping to the source code of a function call, quickly find all references to a specific function or class, intelligent popup of callable functions on an object (again, using Type Hinting to know the object's type).

It's really been a huge difference. Yes, there are some weird things to get used to (default OS X keymap uses a lot of non-standard keys), but overall it's pretty damn useful.

Pycharm gave me overall a better out of the box experience, though at a heavy resource cost (I have 3 branches of my project open and use 1 GB of memory). I've paid maybe 150 EUR to JetBrains for that, but there simply isn't anyone that I could pay 150 EUR to to get a similar experience with emacs.

I'm happy to pay JetBrains even more in yearly renewal costs to make the editor even better.

Have a I spent a lot of time customizing my environment? Absolutely. But it fits me like a well oiled leather glove and makes me incredibly productive. I don't need to learn separate environments for Lisp, C++, XML...

A lot of this is personal preference and familiarity. When I sit down with Visual Studio or XCode I'm completely lost and feel like I'm wearing shackles.

However, I'd feel crippled overall as a developer if I didn't know one of those two (vim in my case). For one thing, a lot of the best IDEs are not free and some are very pricey. I'm not going to go out on a huge spending spree buying a bunch of IDEs just for little experiments I want to do in my spare time. More importantly, though, it is quite often at work that I need to edit code in a variety of languages, and it is simply more productive to be able to edit the code in one editor rather than having to fire up multiple IDEs. Not to mention the need to occasionally make quick edits from within a terminal.

Using vim frequently also keeps me up to speed on terminal commands for lots of modern tools. When I was in college I used IDEs almost exclusively, and whenever I found myself needing to do something from the terminal, my God it sucked. I was crippled. Now I feel more like a jack of all trades who can be productive in mostly any environment.

Anyway, IDEA is always putting developer experience first, so it's well-deserved.

And the skill is transferable to MS Word/Sublime/Google Docs/Notepad/Eclipse/VS/any-other-text-input-everywhere-ever!

b) Even then, I find it more error prone to reach over for the Home key, hit shift, etc...

c) 2+n is still 1 more than 1+n ([Ctrl] [l] [l] [l]). ;)

It's admittedly a minor thing; I just got really comfortable with Ctrl-l in Sublime. I should probably just get over it.

Macbooks all support fn + arrows to do page up/down, home and end.

  fn + left = home
  fn + end = end
  fn + up = page up
  fn + down = page down

Edit: Reverses, in it selects smaller portions of text, again, based on syntax.

Are any of you running it on 64 bit linux and if so - have you found a way to fix the way fonts look?

I do when I browse Java and Scala code.

I'm not sure what problem you mean, but I have to run `wmname LG3D` before running idea, otherwise the fonts are not displayed at all.

With that, it runs fine; the only (minor) problem is that switching to another window and back to idea makes the cursor disappear and some point-related shortcuts stop working until I open any menu/window within idea.

I use a tiling window manager; I wonder if it claches with the Java UI library somehow.

For instance this is how Go code looks in my IDE: http://i.imgur.com/jcWVFuS.png

Some people don't like the blurry look but I have grown quite fond of it.

Personally I like to add this line to bin/idea.vmoptions

  -Dawt.useSystemAAFontSettings=false