Slashdot Mirror
Java Development: Eclipse or IntelliJ IDEA?
Java_Good_COBOL_Bad asks: "For Java development, would most people recommend using Eclipse or IntelliJ IDEA?
I am currently using Eclipse and it took a long time to get the environment set up. I understand that Eclipse is a framework that can be used for many things, not just Java development, but all I really need is an IDE for Java. So, I wonder if Eclipse is more complex than I need.
I have never used IDEA before. Is it more straight-forward? Has anybody here migrated from Eclipse to IDEA? How steep was the learning curve?"
IntelliJ == NOT free
That's enough for me right there.
(Netbeans == free, but Netbeans == sucks)
IDEA is the best IDE I've ever used. It automates pretty much every mindless code navigation/generation/refactoring task, but stays out of your way otherwise. Really, it's not so much an IDE - more an souped-up, heavily-Java-specific text editor. There are no wizards, and it never hides code from you. It just takes a lot of the tedious tasks out of coding.
It's not hard to use, but the sheer array of features can take some time to discover and learn to use. It is very definitely "straightforward".
Eclipse is not bad - IDEA is expensive, and Eclipse is a decent free alternative. But if you have the money, there's no reason not to use IDEA. Eclipse has always seemed to me like a poorly-executed IDEA clone. Similar to most open-source desktop software, really.
And don't listen to the masochists who will tell you a text editor and the command line is all you need.
IDEA has a 30-day free trial - why don't you download it and give it a spin?
This space intentionally left blank.
Depends on what you need to do, which frameworks your using. I've found IntelliJ integrates with a standard IDE-neutral build xml and custom tools like XDoclet much better than Eclipse. Eclipse demands that your project be built inside Eclipse to use any Eclipse tools. The default Java editor in IntelliJ is nicer than Eclipses as well.
If you're supporting multiple developers, Eclipse can be easier to get people to standardize on, making debugging the dev environment easier. If your doing JBoss work, the Eclipse based JBossIDE might be nicer than IntelliJ, just because everything is setup already. Avoid Rational Application Developer at all costs though, it probably needs a couple of revisions before the IBM over engineering gets out of your way and lets you work.
It's been a while since I've tried to do web framework stuff in IntelliJ, although it's always handled this a lot better than the plugins for Eclipse that I've seen, it never handled XDoclet integration well enough to deal with tag library and struts tags. That always made some nice features useless. Eclipse is just as bad, I've yet to see a good set of plugins that handle all the tools I use in a standard Java dev environment. Many of the plugins seem to expect things done the Eclipse way, or they become useless. I wouldn't mind doing things the 'Eclipse way' if that were synonymous with IDE-neutral, but until then, the Eclipse way won't cut it.
The thing that annoys me the most about all these IDEs is the lack of imagination in tool-building. Very few graphical tools handle the IDE-neutral environment well, the wizards and syntax highlighting engines tend to be extremely inflexible. If my project needs JUnit testing, why wouldn't I do an automated nightly pull and generate a public report everyday? Wouldn't my IDE only be helpful if I could do the Unit tests outside the IDE, without figuring out a boatload of crypticlly stored dependencies?
Anyway, I'd try each of them out with the particular features you need, and make sure to check that they will easily integrate other tools you'll need. Java IDE's could be a lot nicer. Both Eclipse and IntelliJ have made great improvements, but this is more a half-way point than anywhere near a victory lap.
Arrogance is Confidence which lacks integrity. -- me
Sun java studio creator is netbeans 4.1 with some added propriatary plugins for drag and drop JSF coding... And eventually it should pull in nebeans 5.0 features as well. Drag and drop JSF is very important if you work in a shop that is constantly teatering towards ASP.NET because it is basically the same product. If you work with people who don't have the greatest skill set this can make them productive at building web gui, and netbeans/swing will always be better at building stand alone swing apps then eclipses attempts. Netbeans is much better then it used to be, but it is still occward in a lot of ways. The one standout feature that I like about netbeans is that ant is integrated into the IDE much more completely, there is no way to build a netbeans project without haveing a working ant script that can also be run on the command line. Other IDE's don't force your hand the same way, and I really hate projects that are not written in such a way that you can just check them out of CVS and build them/deploy ear files... Also netbeans 5.0 has a profiler that is still not working very well, but when it does work it will be a very nice addition. On the other hand eclipse is really very easy to work with, and works very well. The GUI is very nice and very consistent, but I think that swing has the possibility of being much better then SWT, so feel free to ridicule spelling errors in this post and call me an idiot.
You should also at least look at NetBeans.
Anyway, I have used all three of the big Java IDEs.
While they all share the same basic functionality, like great refactoring, ANT, and JUnit support, each has some areas it excels in. I would say IntelliJ is slightly better than eclipse (the free version, I have never used IBM's eclipse based environment), and both of these I prefer over NetBeans.
The main reason I prefer IntelliJ (if you can afford it) is that it has more useful shortcuts, more intelligent formatting capabilities (if you press enter while in a quoted string it will automatically insert the needed quotes and plus sign and place the rest of the string on the next line, and back again).
One feature I really like, that from what I remember is only in Eclipse, is incremental building. The other two require you to hit a build button before hitting the run/debug button. Not that I'm lazy, but you really get used to it building automagically when you hit save. One thing I find kind of annoying about Eclipse is that it doesn't include support for say, xml editing, which the other two support out-of-the-box, instead requiring you to go to their site and finding web-tools plugin. Also the internal parser used for error marking often requires saving the file before it will refresh the markings on the page.
The reason I put NetBeans last, is that it doesn't include quick fix suggestions. Its nice to be able to hit a couple of keys and have the IDE suggest and fix simple problems without having to look at a reference, or moving a bunch of code around.
From my experience all three of these IDEs take about the same amount of setup when you get passed simple applications, so if you had trouble with Eclipse, I don't think IntelliJ or NetBeans will be much simpler.
There is always javac I guess.
Dr Java has a shallow learning curve because it is simple. TOO simple. I would never use an IDE anymore that only does syntax coloring. All three main Java IDE's (IDEA, Eclipse and Netbeans) parse the text you type by default. This means you can easily see what's a local variable and what's a field. See if your application contains unreachable code, bad switches, bad expressions and of course on the fly refactorin.
Especially Netbeans will support additional code checks in the future (think checking if your regular expression or printf statements are valid (IF they can be checked). This is the future for source based IDE's. I would *never* use an IDE that does not keep an abstract syntax tree up to date in the background.
That said, Dr Java does seem to have an nice place to run test code in. I would love to see somthing better than "java (s)crap pages" in Eclipse. Say, a nice beanshell plugin that can also run in parallel with the debugger.
Personally, I have used both in the workplace. I have found IntelliJ to be:
1) more expensive
2) more intuitive
3) more reliable (ie: searches in Eclipse regularly left items out)
4) faster
I would say that #1 is your deciding factor. If you are willing to spend the money on it (you can usually get it for 1/2 price for a Personal copy -- and free for open source projects), it is a much better product.
Some will argue that Eclipse is better because of the fact that it is open source. As much as I prefer open source software, I was willing to spend the money on IntelliJ for home because of #2-#4.
Some will likely point out that #3 just means that I was likely doing something wrong. It wasn't just me - it was the entire team. At the time that I noticed this deficit (last year), the entire work team was required to use Eclipse; and a few of us switched to IntelliJ (and honestly a couple to JBuilder as well; no one switched to NetBeans, though we tried it) because all but 1 of us despised how Eclipse performed.
If you aren't looking for something with all the bells and whistles, you might just want to go with a much cheaper solution like JCreator (which I also paid for) -- but I personally would recommend IntelliJ.
http://www.google.com/profiles/malachid
I've never been a huge fan of Integrated Development Enviornments. The learning curve is usually quite steep, each has its own peculiarities, and each does things you originally had no intention of doing.
Case in point, Anjuta, on the creation of a new app, creates a 500K config file and I have no idea what it's doing. Each IDE also has a tendency to create its own directory hierarchy, make file or equivilent, and if versioning is included, will pick its own scheme.
What this usually entails for me is loss of control over the project. I sort of feel trapped within the IDE, and unable to get out. The Visual Studio effect; I don't know where my code ends and the automatically generated stuff begins.
As such, I prefer keeping it simple. I use a bare text editor where possible. Syntac highlighting is a must for me, and I've found very few editors that do this correctly. Emacs will work if your colour scheme is OK, but Emacs is a quasi-IDE to begin with.
I find writing computer programs to be just that. Writing. It's a personalised sort of thing. A few personally written shell scripts, a handmade makefile, the command line and a decent editor can go a long, long way. You are intimately aquainted with all aspects of the project. On the downside, you are intimately aquainted with all aspects of the project.
Your milage may vary, considerably. But before you begin to use an IDE, as what it is giving you, good and bad, that a personalised DE is not. There's a trend towards monolithic IDE programs that do it all in one, but do they really deliver on their promise. Are you really more productive. Your troubles with Eclipse could be symptoms that IDE are really not for you.
May the Maths Be with you!