-- CAUTION: Serious rambling ahead... --

Eclipse is the non-commercial result of a committee of developers so wide and uninvolved in each other's greater visions and monetization strategies, that the user-experience of the base platform is "functional" at best.

I can cope with just "functional" (and stable) but Eclipse is "functional" only -- the core platform (UI, plugin framework, all core Java/source tools, etc.) are really stable and robust.

Everything else built ontop of them (custom editors/designers, Web tools, all of WTP, Maven tooling) basically all the ++ resources are unbelievably memory hungry (turn on the heap monitor and watch it when you run the Update Manager > Check for Updates... seriously, just watch how many objects are instantiated and GC'ed in that simple cycle, 100s of MBs) and generally broken.

To that point, the "design by committee" environment leads to overengineering that you cannot fully appreciate until you start trying to build ontop of those APIs. If you hate yourself, try and build something ontop of WTP from scratch (like custom tech support, like a Play IDE).

Also interacting with the Update Manager concept that has tried to become so much more but has been hammered into this "jack of everything-even-stuff-no-one-needs, master of nothing especially the thing it is suppose to do"

The intelligence needed to correctly calculate an update plan based on plugin versions and interdependencies is worthy of a PHD -- if you've used Eclipse for an extended period of time and upgraded yourself into a corner that the Update Mangaer cannot update you out of, then you know what I mean. If you are a long-time user you've heard "Try a new workspace" or "Do a new install" more times than you can count as far as trouble shooting first-steps.

Eclipse is an odd ecosystem. The only money to make by EVERY company involved is in +1 features that have not been commoditized by the platform.

Unfortunately these are ALL the developers contributing to the core platform, the same ones trying to keep their pay checks by developing tools ontop of the core. There is no desire to cannibalize their own products and markets by contributing that stuff unless they absolutely have to (for fame or strategic reasons, take your pick).

The move to 4.x was a total redesign of the platform to make it "Web friendly" I think, I have no idea... but it was a major-major overhaul of the core platform and the result is a buggy/slow/mess even at the core level that has long since stabilized.

Anything beyond "core tooling" available in the open-source bundle is going to be what I would consider a "best intention" implementation. Not good enough to put anything commercial out of business and not bad enough to be berated or ignored completely... just bad enough to make you crazy with rage if you depend on it day in and day out, but good enough to seem cool if you are doing a tool evaluation. That said the stuff that gets used by EVERYONE (e.g. Java code tools) is great because it is in every contributor's best interest to have that stuff rock (their day jobs). For the tooling that is very specific to a team or company, definitely not the case.

IJ on the other hand is a single product backed by a single company with the sole focus of being as-good-as-it-needs-to-stay-commercially-competitive. JetBrains has to spend money to convince people to spend THEIR money... the market is forcing this product to get better and better and those developers appreciate things like rewriting a plugin framework to keep it fast, rewriting the code-completion parser to update faster, etc... the kind of stuff that is huge technical debt after 8 years that an OS project can almost never justify sticking on someone's bottom line to rewrite.

That said, I actually dislike some of the core project paradigms used in IJ which is the only reason I don't swear by it heart-and-soul. The dev experience is much more stable, performant and consistent.

If you want a corollary of what I mean about "paradigms" consider the IJ UI builder compared to the NetBeans one -- NetBeans when NaturalLayout came out was all about "Drag and drop with snap-to rules" -- it was intuitive as all hell.

IJ on the other hand was all about FormLayout-like behavior and a way more technical experience with weighting and splits and bindings.

Both were pretty stable and worked great, but took very different approaches. If you bought into the IJ model it was awesome and you had a great time using it.

If you were like me and wanted the preferred-spacing snap-tos guiding your design, it was a pain and you much preferred the NetBeans UI designer.

So if you are doing core Java dev work, Eclipse and IJ are both awesome. If you are doing Web Dev/Spring/JavaEE/JSF work -- try them both, the bugs in Eclipse will eventually drive you crazy I imagine though and I am NOT saying IJ is better, it is different, and in some design/paradigm ways less intuitive in my opinion which is what keeps me from just recommending it to everyone I meet on the street.

NetBeans falls somewhere in here... I think in a lot of ways it is an unsung hero, has some nice polish that the others don't, very human friendly but is also missing some hard-core functionality that you find after about a month of use in my experience. Back in the day the real-time compile and auto-complete speed of Eclipse kept me away from NetBeans. The "based on Ant/maven" building design was a decent call I think, I get why they made it when they did, but it did cost them some things.

The NB team has shored up the editors quite a bit so I think most is caught now during editing. I am meaning to try the 7.2 beta so maybe I'll be happily surprised.

I haven't used the last 2 versions of NetBeans though -- the Javadoc formatting always moved me away from that one as well.

What a silly reason, I know -- should stop writing so many comments :)