Caught Between Two IDEs
I seem to be caught between two IDEs: Eclipse and IntelliJ. I abandoned Eclipse a couple of years back, partly based on wide spread recommendations from many different people, and partly because Eclipse just stopped working for me (it crashed out).
After I got started with IntelliJ I started to appreciate its merits, despite a generally clunky interface (with lots of modal windows), truly awful documentation. Many things are streamlined and only a ctrl-alt-shift-coke-bottle-touch-your-nose away.
However, over time, using IntelliJ got slower and slower and slower. It also started running the Tapestry test suite horrifically slowly: 40 minutes and up (it should be about five). It would often go away, even when memory wasn't tight. Indexing? Checking Repositories? Computing primes? No way to tell.
Meanwhile, Eclipse has been moving forward, with Eclipse Galileo being a Cocoa (not a Carbon) application. Critical plugins such as M2Eclipse have gotten nice, and the Clojure plugin is mostly better than the IntelliJ one (though both are very early).
For a while I was using IntelliJ when teaching Tapestry (as part of the VMWare image I use when training) ... and I got a lot of resistance. People were much happier with Eclipse on the last couple of go-rounds, and I'm sticking with it.
Overall, I'm feeling that most of what I've grown used to in IntelliJ is present in Eclipse, just handled a bit differently. The Clojure plugins are a wash; IntelliJ has the edge on the Git plugin. I think Subversion inside Eclipse is actually better.
I've even cranked up NetBeans but didn't find anything there compelling enough to switch.
It seems like all my major tools (Firefox, Firebug, Eclipse, IntelliJ) are in the habit of growing too complex, and doing too much stuff in the background that I don't care about. All those intentions in IntelliJ that you have to turn off (for performance reasons), and all those extra plugins for Eclipse that you need to not download in the first place ... they're all getting in my way.
I think a lot of this falls into the general category of accidental complexity ... to address the limitations of the Java programming language, all this extra stuff is coming into play: tools and wizards and plugins and indexes and whatnot. I find it pretty pleasant to work with Clojure instead, where the accidental complexity of Java is managed and isolated and the IDE doesn't feel the need to be overly ambitious. That's the Clojure concept right there ... grow the language to your needs, rather than building up tools. I think that's the Tapestry ethic as well.
From http://tapestryjava.blogspot.com
Creator of the Apache Tapestry web application framework and the Apache HiveMind dependency injection container. Howard has been an active member of the Java community since 1997. He specializes in all things Tapestry, including on-site Tapestry training and mentoring. Howard is a DZone MVB and is not an employee of DZone and has posted 18 posts at DZone.
- Login or register to post comments
- 5444 reads
- Printer-friendly version
(Note: Opinions expressed in this article and its replies are the opinions of their respective authors and not those of DZone, Inc.)
Comments
Andrzej Grzesik replied on Fri, 2009/07/03 - 4:33am
gseaton replied on Fri, 2009/07/03 - 4:46am
programr2k replied on Fri, 2009/07/03 - 10:23am
I'm really glad you wrote this article as I'm doing the same decision-dance. I love some things about IntelliJ, but using Eclipse makes my students and pair-team-members so much happier. And though I could gain some individual productivity from IntelliJ, with "Agile", "Pairing", and "Coaching" dominating my life these days, it's more about the benefit to the collective than for myself, and that equals Eclipse.
Looking forward to meeting you in person when we both are presenting in Seattle...
-Matthew McCullough
John Broglio replied on Mon, 2009/07/06 - 1:46pm
I have tried switching to Eclipse, but run into two or three problems. Things that keep me from switching to Eclipse:
Build process. Eclipse seems to need to build a project itself (not through ant) in order for error checking, etc., to function properly. That means dual maintenance for builds. IDEA has been happy to use ant.
Key bindings. When I first tried to switch to Eclipse, every module/plugin/view had its own key-binding mechanism, so my emacs-style key bindings, which were PAINful to customize, went away when I switched from Java to xml view. There's got to be an easier way.
Large projects. IDEA uses parsing/indexing for error-checking and suggestions. Eclipse appears to depend on the compiler. In a big project on an average machine, every minor mod takes you through the whole build process before you get any info. Alternative is to turn off auto-build and try to remember to turn it back on when you want to look for errors or get info on your new code. Both ways seem onerous.
Project structure. I'm vague on this at by now, but Eclipse seems to be pretty religious about where source code and libraries can lie in relation to the workspace. Our Eclipse guys do a checkout and then copy directories into their workspace to get around this.
Minor things. Changing the Java language level was a black art last time I looked. Too many dialogs do similar things in remotely different places. Does "encapsulate variable" still coexist with "generate get/set methods" and do they still do the same thing differently (especially if you have an existing get or set method)?
I'm always looking for solutions to these hassles, so I could switch to Eclipse. The bright Eclipse users in my office haven't found any. (Six months ago, I stopped accepting the excuse "I can't run/test that with Eclipse".) Every so often I try out a new version of Eclipse to see where it's going. With the user-UNfriendly plugin finder and the other issues, it is usually worth a day just to find out that not much has changed. So I still own my own version of IDEA which I upgrade every couple of years. Someday...
Walter Bogaardt replied on Mon, 2009/07/06 - 5:26pm
Know the pain, but sometimes $ comes into play, and you have to go with the free version. Depending on your mode of development one IDE rules over the other. Netbeans is an example where it still hangs on and is good for mobile development. IntelliJ not so much. Eclipse has gotten better and more web enterprise capable. I don't know if I like the continous building right off the bat, but you can turn it off.
Still my preference for refactorings is intellij. Never steered me wrong. Alas though I have to go settle with Eclipse until I find funds to get intellij.
jexner replied on Tue, 2009/07/07 - 9:54am
Gordon Milne replied on Wed, 2009/07/08 - 5:21pm
I long ago disabled sync-on-frame-activation and that worked for a while but every major release seems to get slower and slower.
Having said that, I do like the way my fingers have remembered the keystrokes. I was an Eclipse from 2003 until the IDEA switch sometime in 2005. I found IDEA to be a lot more understandable and easier to work with. Eclipse was, for me, a bit suspect, especially the way it went down the SWT route. I still consider IDEA to be better.
I try Netbeans out a few times a year. I think its the easy-to-access refactorings that keeps me with IDEA.
I just wish it was faster.
I know the answer to my performance problem ... get a newer PC. It's in the budget, but the budget got frozen. What I need is one of those quad core boxes the mechanical engineers have. Whilst the software developers have two monitors (1680x1050 + 1280x1024) we have definitely lagged behind in the horse power stakes.
And I need those new boxes for my team too, no matter what they say about them being good enough.
John Broglio replied on Thu, 2009/07/09 - 2:39pm
in response to: wb110497