Comparison between IntellijIdea
(Ariadna) build #640 and EclipseIde
I have been working almost a year with IDEA and am now trying Eclipse. Here are some remarks as I discover Eclipse.
- CVS integration
- Eclipse: Ability to see incoming and outgoing changes
- Eclipse: Ability to see an uncommitted change through the whole directory structure
- Eclipse: Ability to compare current version with any other version in the repository.
- IDEA & Eclipse: Ability to commit a file by right-clicking in editor pane. Very convenient
- IDEA & Eclipse: Show the changes that will be performed before doing them
A good article on the topic from an Eclipse fan: http://www.manageability.org/blog/archive/20021113%23idea_3_0_an_endless/view
IDEA's refactoring support feels more mature than Eclipse's, with more features and a smoother GUI.
IDEA seems to support a broader catalogue of refactorings than Eclipse.
Update: eclipse in the last couple months have added many new refactorings, and give two alternate UI's for refactoring (the lightweight one is quite nice)
I've asked an Eclipse developer about the differences between IDEA and Eclipse regarding refactorings. His answer was that the main difference is that Eclipse goes at great lengths to analyze your source code thoroughly and *guarantees* the correctness of the refactorings. If it can't guarantee it, it issues a warning and might even refuse the change. It seems that IDEA, although its gets it right 99% of the times, is less strict in this area.
Eclipse can be customized in this aspect: if you want 99.99% guaranteed code, it will provide it, if you want a 'best attempt' it will try its best, and if you want to decide case by case, it'll give you a preview/original diff, and let you choose - useful when you accidentally (or intentionally) override a variable or method while renaming it.
Additional remarks by Franck Rasolo:
- Text/Java search
- IDEA & Eclipse: Ability to find usages of class and instance members
- IDEA & Eclipse: Ability to view TODO items contained in all resources on a given project path
- Eclipse: Ability to view and filter errors, warnings as tasks in the task view, in addition to user-defined tasks
- J2EE support
- IDEA: Built-in support for EJB and Web Applications
- Eclipse: As good as your preferred combination of third party plugins
- Plug-in architecture
- IDEA: Open API currently under development
- Eclipse: Extensive API and large number of extension points to internal plugins (Eclipse is designed to be a platform for something, the Java editor is a proof of concept)
Find usages does not work in Eclipse [fullstop] like it does in IDEA. I'm comparing Eclipse 2 to IDEA 2+.
Basically in IDEA if you attempt to find usages of method m on class C, IDEA will find only those instances (or give you the option of finding usages up or down the inheritance/implementation hierarchy). In contrast Eclipse will find all usages of any method named m on any class. This isn't particularly helpful if you want to find usages of the toString method of a particular object.
I have a (large) handful of other Eclipse experiences like the above - essentially IDEA works as I expect it to all the time, and Eclipse sometimes does the most bewilderingly stupid things possible.
Incorrect. I just verified in Eclipse 2.1 that Search->References only finds references to a method called on instances of the current class. I'm pretty sure 2.0 was the same way.
A few years ago I used Idea exclusively and avoided Eclipse. Now I use Eclipse most of the time. Can you elaborate on these other bewildering behaviors?
Perhaps there is something SERIOUSLY wrong with my version of Eclipse (2.1), but Search->References for toString of a certain class (i.e. a class which overrides the implementation of the toString method) returns a list of ALL calls to toString on ALL classes while/before saying "There was an error with your search" (or words to that effect). In fact the I find the Search support is pretty poor. (Actually immediately after posting my initial comments Search->References DID work as it should, but subsequent attempts to do the same thing consistently failed miserably).
That's not what you said. You said Eclipse would find "all usages of any method named m on any class". Eclipse finds every reference to Object.toString(). If A has fooBar() and B has fooBar() and neither A nor B are subclasses of the other, searching for references to A.fooBar() won't return uses of B.fooBar().
I never searched for Object.toString(), I searched for usages of package.ASpecificObject.toString() where ASpecificObject's toString() implementation overrides the default implementation. The issue here is that Eclipse does not seem able to perform the search as I would expect, whereas IDEA will provide the expected search and also give me the option of searching for calls to the superclasses' implementation. Given the use of inheritance and implementation in Java and assuming that Eclipse cannot distinguish between specific implementations of a method/whatever (which seems to be the case) I see its "Find Usages" implementation as inferior to IDEA's. This issue neatly summarizes my feelings to Eclipse - it's all very well to compare feature lists with IDEA, but when it comes to the crunch it seems to me that the actual implementation of features in Eclipse is not as good as the implementation of the same features in IDEA.
In this case the Eclipse behaviour seems correct. Any usage of Object.toString() really could be a call to ASpecificObject.toString() at runtime.
Yes, but IDEA will let me specifically look for calls to ASpecificObject.toString() or calls to Object.toString(), do you not agree that IDEA gives the users more in this situation?
, but I use it for Perl (with the Epic plug-in).
The issue here is that Eclipse will not let you define .js files as a kind of text file, which IDEA does (assuming it doesn't provide support for .js files already ) - essentially this is not an issue in IDEA, but with Eclipse I have to remind myself that I have to open a .js file in a different way from other files. Sure, maybe I can get a plugin for it, but (1) why should I need a plugin for something so simple? (2) which plugin do I choose? for any given feature there are frequently multiple plugins.
Have you ever tried, from the menu bar, Windows->Preferences to open the preference dialog. Select Workbench->File Associations in the tree on the left, click the "Add..." button on top right for extension "*.js", and then select it and "Add..." the Text Editor to it?
No I haven't because this option wasn't obvious to me. In IDEA a popup notifies you that IDEA does not identify files with the given extension and then allows you to treat it as a known file type, e.g. a text file, an XML file, etc. In IDEA I don't have to go and find options they present themselves to me.
[If I were your colleague, and I have to hear this kind of "IDEA is better" rant after helping you use Eclipse, and hear it at least once every day... I would have said "No." as a standard answer eventually, regardless of your question. <only partially joking>]
Latest bewilderment: right now Eclipse is not handling tabs consistently.
I find the much-vaunted plug-in support in Eclipse underwhelming. None of the the Eclipse plugins seem any better than those offered for IDEA (i.e. SQL plug-ins for both platforms more or less do the same thing... well, Eclipse provides several alternatives, a few of which don't really work that well) and the Eclipse plugins that supposedly make up for the features of IDEA that Eclipse does not have do not provide implementations as solid as those offered by JetBrains.
The similarly lauded constant compilation or whatever is retarded - it's over-zealous and reports things that are obvious because I'm in the process of editing code. Importing classes is a pain, type the class name, save, wait for the screen to scroll up for some reason, and then finally comes a pop up list offering me what Ctrl+Enter does in IDEA without all the superfluous nonsense - i.e. in IDEA type the class name and Ctrl+Enter and your pop up list is there, no compilation errors.
I have no idea what you're talking about in the previous paragraph.
Eclipse's method for adding import statements to your code is much more cumbersome than IDEA's elegant Ctrl+Enter technique.
Have you tried Ctrl-Space? I type in a class name and hit Ctrl-Space and a pop-up list is there. Actually, if the class name is unambiguous as it usually is, the import is just added without bothering me with a list. I rarely even think about imports.
No I haven't, again this is not obvious in Eclipse, because by default Eclipse presents the retarded mouse-clicking option, whereas IDEA informs you that Ctrl+Enter is the key combination to bring up the list of possible imports when it comes across a reference to an unknown class. Yes, IDEA will also import unambiguous classes without giving you an option list.
["retarded mouse-clicking option"? What is that? Ctrl-space is Eclipse's auto-complete key combo. If you use it imports will be added automatically. If you don't use it, why not?]
According to the Source menu the key combo is Ctrl+Shift+M. Ctrl+Shift+M and Ctrl+Space both work. WOW Eclipse is the greatest EVER it has TWO key combinations and a default implementation using the mouse (which is retarded, the editor window scrolls for some reason). IDEA's default mouse implementation tells you what the key combination is - you don't have search the menus to see what the combination is - IDEA makes an effort to let you know about its features and how to use them, while Eclipse does not.
Furthermore while Eclipse supports refactorings "just like IDEA" it doesn't support as many refactorings as IDEA and I don't feel Eclipse handles refactorings as well as IDEA. For instance, at least by default, Eclipse does not change JavaDoc tags if you change a methods parameter names.
For the price Eclipse is a fine IDE, but for not very much money IDEA is a superior IDE. I think the examples I give show this.
What are the CodeInspection? features like in Eclipse?
In comparison to what was listed on the IntellijIdea
, Eclipse can be set to mark unused methods, variables, as well as a few other things, as warnings or errors, or ignore them completely. As far as I know, it doesn't support the 'branches that never get executed' bit, at least beyond what the compiler already considers 'unreachable code'. I'm not dead sure I quite follow what you mean by CodeInspection?
in this context, though. -- cwillu
What I meant all those weeks ago was that in IntelliJ I can run a command which will scan all the code in my project and display the various problems it finds. This ranges from unused methods, local variables that are never used, access rights that could be more restrictive, code that has no side-effects, methods that always return the same value, methods that always get called with the same argument, methods which can be static, etc. Running this on the code in the standard Java API is rather worrying as it identifies objectively
what a mess things like the regular expression code package are. -- AdewaleOshineye
No, it doesn't specifically come with this, but there are at least 4 free third party plugins that do, and they all integrate quite well with eclipse.
IDEA has support for Ant file refactoring!
Interface Niceties That Both Eclipse & IntellijIdea Have
- Definable 'templates': Type in 'for' and hit CTRL+SPACE and it'll popup a menu giving choices between several for loop structures. Select the one you want, fill in the first occurrence of each name, and your done. (I just wish normal renaming could be done like this in eclipse... oops, spoke too soon, you can) :)
The ease of use and speed of the interface makes me feel more productive. At my workplace, the "standard" IDE is IBM WSAD (derived from Eclipse 1.0), and it's a dog. Sometimes it takes 10 seconds for a context menu to pop up. What's the point of a tool with tons of features if it slows you down? The speed difference between these IDEs is like the difference between running downhill and running in a pool. -- KenLiu
Not fair to compare v1,
much progress has been made with v2. Admittedly, Eclipse can be a bit slow the first time a particular type of function is run, it only takes a few seconds before everything is running snappily (I'm running a k6-2-450 with 256mg ram on winxp, with no complaints)
Update: Again, a lot of work is being put into fixing problem areas in performance, the last couple months have improved again somewhat.
A note from an avid Eclipse user: I recently downloaded the Idea evaluation version. My coworkers stood behind me slack-jawed as we waited for the Idea editor to respond to keypresses. So, this is definitely a case of YMMV. We find Eclipse much more responsive in the UI than Idea. For what it's worth, we also find the JavaSwt
-based UI far more legible and elegant than the JavaSwing
-based Idea UI. Had you configured the timing in the options?
'Evaluation' as in the Early Access Program (EAP)? Certainly might be slow since they don't optimize until it comes close to release. Not really a fair comparison though.
No. Just the download you may try for 30 days for free.
Refactoring Notes: I trimmed a few of the bullets from Interface Niceties
above. I had previously listed a couple of features of IDEA I thought Eclipse lacked, but someone pointed out how to do them with Eclipse. If they both do it, it probably isn't worth listing here. -- RodWaldhoff?
It might be, to give an idea of how much both of these editors have
[out of date information removed... it's already caused confusion (IDEA used to be available free as a beta, but hasn't been in some time now)]
But you can
get a free evaluation key at http://www.intellij.com/idea/download.jsp
How is IDEA's plug-in support? The great thing I like about Eclipse is the ease of writing plug-ins. Eclipse doesn't come with a good .properties file editor (or did I missed it?). I whipped up a working one in a day, from never writing a plug-in, and in an another day, having one working to my liking.
IntellijIdea has great plug-in support. One can get plug-ins from here:
They include things such as UML diagram generation, IRC client, Jython integration etc. Seems like most things can be adjusted and customized with plug-ins.
I disagree. I would characterize the Plug-in documentation in Intellij as haphazard, telegraphic and fragmented. They have been saying "better documentation coming soon!" for over a year now.
This is actually, I think, a death spiral for them and a huge object lesson to future IDE developers; if you don't harness the power of your user base, then someone else will, and the stampede will be thunderous.
The most serious and sophisticated minds are dedicating publicly derived money to instantiate their equally sophisticated and useful ideas as Eclipse Plug-ins. IntelliJ is treating plug-in documentation in a "we'll get to it" fashion. Eclipse is free and open source. This is terrible for IntelliJ; even though their product is great, how can it compete against Universities all over the world embracing Eclipse as an R and D platform? Yikes.
What IntelliJ should have done is
- made their architecture lend itself to being extended by John Q. Public
- made their documentation drop-dead gorgeous and accessible, clear, and friendly
- offered a free lifetime versions to anyone whose plug-in was included in their distro.
That's a lot of good code for a not very big price, even in programmers are paid in rubles.
I can't believe any of the IDEs are going to survive the Eclipse juggernaut, quite frankly. NetBeans
might as well stick a fork in itself, even though the polite thing to say is NetBeans
and Eclipse can coexist.
Don't get me wrong.. I think JavaSwt
was a HUGE mistake of the NIH variety and I sincerely wish it would somehow get retracted. SunMicrosystems
originally did this in JavaAwt
and they paid the price, then invented JavaSwing
; SWT pales in comparison to Swing and splits the Java developer community in a way that must have Microsoft salivating.... and quite honestly, IBM is not such a great company to work for for those over 40 or those prone to getting cancer, if you believe the newsgroups, but nevertheless, Eclipse is snowballing in a way that has to have the CEOs of other IDE makers staying up late trying to map out how to dump their stock and not have it seem suspicious.
Well... I'd rather work with SWT any day of the week. AWT was a failure because it got rushed. E.g.: my touchpad driver does some ugly things to emulate scrolling... ugly things that do work with windows apps, effectively anything using a native widget. The emulation works transparently with SWT. Swing, on the other hand, sticks out like a sore thumb. Swing is itself a NotInventedHere error: why would anyone want a window system which has zero integration with which ever windowing system is native to the host?
I've used Eclipse v2 for a while now & have just been trying IntellijIdea
since all of my new fellow developers are keen on it (though we do have the choice). My problem with Idea is that it (to me at least) is a retrogressive step from the Smalltalk / VisualAge
/ Eclipse idea of having a (package &) object browser & going back to a file-based view. To me, the package view of Eclipse et al gives an invaluable architectural view of an app that you don't have from a simple file-based view. Any comments?
How has this view influenced your day-to-day work? How does the file view prevent you from making this change? Can you describe in a little more detail the two views and their differences?
My day-to-day work involves taking an architectural overview of large-scale systems, attempting to spot commonalities and to avoid point solutions. One of the major issues in software development is when developers concentrate too much on detail and not enough on commonality and abstraction - it leads to highly entropic codebases.
Java's packages aren't hierarchical and in that way don't map directly to the file system. .NETs namespacing is much more explicit about that - there the file structure is related to modules/assemblies rather than namespaces.
Having a breakdown of Projects / Packages / Types / Members in the Java Browsing Perspective within Eclipse allows me, at least, to traverse the various levels of abstraction of a system within the IDE. Day-to-day, it lets me conceive of and work with the system as a whole, made up of a number of modules, which in turn consist of a number of packages, etc.
I don't understand how the file view prevents you from looking at the system this way. I don't seem to see the problem you are describing. In Idea, there are dozens of ways to navigate through the code, using Ctrl-Click and its variations, Ctrl-H for class hierarchy, Ctrl-N to find a class by name and/or package, Ctrl-F12 to navigate the structure of a file (i.e. methods, fields in Java files), and Alt-F1 to find the current file in the Project view. And if I'm looking to keep the codebase from becoming 'entropic', I use the refactoring and code inspection tools. If I need a higher level view, I use UML.
But that's all class based, bottom-up, starting at a single class and navigating through the codebase. With Eclipse & its antecedents you don't need to use the UML (through whatever reverse engineering method) to get a top-down or middle-out view - you have higher level views within the IDE.
This is all very hand-wavy. I can't see the problem. Perhaps a screen shot, even of some dummy classes/packages, would be helpful in illustrating this. Maybe a look at some Tomcat or Ant code through the eyes of Eclipse would be a good example.
Well I might as well add my 2 cents. I've used Idea 2.0 and 3.x, Eclipse 1.0 and 2.0 (not thouroughly on the 2.0), and finally WSAD (based on Eclipse 1.x). Quite simply Idea seems superior, from the install everything just seems easy and intuitive. Yes, most of the features I like "can" be made to exist in Eclipse (usually in the form of a plugin), but it never seems to flow, one IDE obviously had massive user analysis testing and the other didn't. Also, why isn't there support for really common things such as JSP right out of the box with Eclipse? I mean, come on, I know there is a plugin that works fine, but holy crap, that's a lot to ask of a brand new user, "Hey here's an editor you've never used before, now write me some code." Coder: "ARRRRRGGGGG!"
Another thing I like, the external tools functionality is top notch, allowing me to seemlessly integrate my favorite tools right in to my IDE (like Jalopy and PeeEmDee
) and I don't have to pray that someone has made a plugin for me. Yes, Eclipse has some support for external tools, if you want an exercise in frustration just try and configure it to use PeeEmDee
externally (i.e. not the plugin).
As well, integrated tools are much better supported in IDEA. Why on earth do isn't there a predefined hot key sequence to run the current class as a JUnit test in Eclipse? How about at least a "Run Class as" toolbar? Why is ANT such a pain to deal with in Eclipse? Where is the XML support?
As far as working on a large project where the minimum number of classes I'll have open is about 6 (this really is a minimum for me) plus their unit tests, Idea wins again. They have multiple row tabs and I can always see the whole class name on the tab (making similar names like MyNeatoFooManager?
[I know, bad names] not look the same).
Eclipse has finally become similar in its ability to refactor so I will say there is only a personal preference difference in this case.
I can't speak to Idea 4 as I haven't had the chance to use it yet. I have heard that it has lost some of its ease of use. Overall, however, I would have to say I have always felt that Eclipse is running after Idea, copying many of its features, in fact it seems they just grab the spec sheet for an old version from JetBrains
and start working on whatever suits their fancy.
Bad things about Idea, plugin support is certainly less (I've heard the API is poorly documented too, don't really know). It costs money (though if you are a student it is still $99). Not widely accepted in corporate settings (<sarcasm>a $500 IDE could never be "better" than a $2500 one!</sarcasm>).
Idea 4.5 is AWESOME!