How does IntelliJ Demetra compare to last Eclipse Version
Hi,
IntelliJ Developers out there ...
I am going to write an article about the differences of those IDEs. After using IntelliJ for about 4 years I want to end up with our Internal IDE war by comparing IntelliJ and Eclipse (latest versions).
I will write the article together with one of our greatest Eclipse lover for an almost fair comparism.
Please tell me about your opinion and help me pointing out the advantages / disadvantages (if there are any) of our famous IDE.
Greetings from Germany
TOM
Please sign in to leave a comment.
Hello Tom,
Probably, this can be a starting point:
http://javafaq.nu/java-article996.html
http://jroller.com/page/andersjanmyr?entry=six_months_with_eclipse1
I can provide you with some more links and docs (of course, I'm JetBrains
employee and my opinion will be highly subjective ;)).
You can contact me at Alexandra.Rusina at jetbrains.com
Best regards,
Alexandra Rusina,
Technical Documentation Team Lead
-
JetBrains, Inc
http://www.intellij.com
"Develop with pleasure!"
Hello Tom,
Why do you want to standarize on one single IDE. Shouldn't developers be
free to chose their tools?
(IMHO, Projects should also be IDE independent)
For what it's worth...
For one, JSP/JSPX editing, tagfile support etc blows the pants off of and
other tool. (Including the latest WTP 1.5).
I've seen other (quite competent) Eclipse developers edit view files (JSP/JSPX),
and the productivity boost in IDEA is very big.
Especially the "context" functionality for stuff like Sitemesh decorators...does
any other tool even have this?
Rename refactoring is more reliable when classes are referenced in external
Spring/Hibernate/TLD/web.xml xml documents. Almost always not-in-sync names
are Eclipse developer commits.
Especially for all J2EE artifacts, the completion and validation is just
very good.
JavaScript support and itegration into J2EE projects is perfect, versus an
external plugin for Eclipse with far fewer features.
General Java editing is much more robust, small errors do not prohibit competion
or refactoring (although Eclipse 3.2 has improved somewhat in this area).
The editing/refactoring experience is just smoother both in terms of speed
and user 'flow'.
Built-in SVN support.
These are things I notice when working with / pairing with Eclipse developers.
On the other hand, there are some eclipse plugins that I still use from time
to time (ANTLR Studio (soon to be replaced with AW), Erlang + Ruby plugins)
Eclipse also has a good Maven 2 plugin (by Eugene Kuleshov(sp?)), I miss
this sometimes.
hth,
tt
Taras gave an excellent summary.
I'm going to comment on the two things I see most Eclipse programmers say when they just flat out eliminate even looking at IntelliJ:
1) Sub-pixel anti-aliasing. Eclipse has it, IntelliJ does not because of its dependency on swing. There are some hacks to enable it for IntelliJ but since IntelliJ (including Demetra) is not built on Java 6, it's technically not there for most IntelliJ developers. Hopefully, JetBrains will move to Java 6 for the release that follows Demetra.
2) Eclipse users seem to love those stupid red 'X's that appear in their project file lists when there's a compiler error. IntelliJ now provides this in Demetra. Personally I never understood the need for it since it's completely worthless but this is what seems to make Eclipse users happy shrug.
One of the problems with this kind of evaluation is that IntelliJ does lots of subtle things that just don't show up well in a simple check list of features. The only way to communicate them is to actually demonstrate them. Barring that, you will have lots of trouble effectively showing the (obvious :)) superiority of IntelliJ. I've never been able to convince an Eclipse user to take a serious look at IntelliJ just by talking to them. It's usually when they look over my shoulder when I'm coding that the gears in their head start turning and they realise how cool it really is.
Good luck to you.
Yes, developers should be free to choos their own IDE. But, once the managers and lawyers get involved it is proclaimed that the 'standard' is Eclipse .
Even showing the lawyer the clear languange on the personal licence, permitting me to use my copy at work is not sufficent. And as it is not 'standard' they will not purchase a copy .
The folks setting the standard had heard of Eclipse . That 'comprehensive survey' was the sole basis for their decision. :(
Just my two cents :
One thing I really like in eclipse (and dislike in Idea) is
perspectives, and the dockable toolwindows. In Idea you can only have 4
toolwindows at the same time, and only at fixed positions... I like the
flexibility of having any number of docked toolwindows in eclipse.
Also, IMHO, the general UI of idea doesn't try to save space as well as
eclipse. (And when you don't have dual screen, saving space is important!)
BoD
My two cents: I like IntelliJ's layout a LOT more than Eclipse's :)
Theoretically, Eclipse's views and perspectives seem very cool, but I
never managed to take an advantage from them in practice, somehow
IntelliJ seems much more "intelligent" in showing me what I need now
(vs. always editing my debugger perspective), its just easier and better
using screen real-estate.
Further, I never managed to like Eclipse's project/package view, they're
somehow too cluttered (same goes for NetBeans) - I like the "package
view" of IntelliJ a lot better (also liked it in JBuilder). This seems
simple but is a big deal to me when working with many interfaces/classes.
as said, my two (euro) cents
regards,
Messi
BoD wrote:
I, for one, came to hate perspectives.
The company i work in imposes RAD for software development (IBM additions on top of eclipse 3).
THere is a J2EE perspective, a Java, and a resource perspective.
Depending on the perspective you won't see the same items in the project explorer, this is especially true for non java resources, for which you will need to switch to the resource view. IMHO this is a bad design decision.
I feel the same way about Idea's layout. Perspectives were what turned me off to eclipse because Idea was just so intuitive, at lease to me. I know a lot of people who use and love eclipse, but for me Idea just "feels better".
Not really a big fan of perspectives. They're too fiddly and it's too easy to break the layout.
This thread just gave me notion to share with Intellij marketing.
Why not do a GUI time trial and video tape it?
Eg put Eclipse and Intellij side by side and walk through an editing scenario. Doesn't have to be too fancy but just has to be plausible and "fair" (and one where IDEA will win).
Take the IDEA and the eclipse user through the tasks
My gut tells me that the IDEA user will be able to complete the tasks in a appreciably shorter time.
And a video is the best way to show this -- preferably with the users side by side using split screen and some maybe some running commentary.
Messi wrote:
In general, I have to agree. Sometimes, however, I think that
IDEA could be a bit more flexible in tool window management;
in particular, I miss the possibility to display the "Console",
"Frame" and "Watches" tabs of the Debug tool window next to
each other (like you can do in MS Visual Studio).
Regards,
Jens
In Eclipse I really miss the module concept. OK, one can add separate
projects in the meaning of modules, but it becomes very difficult if you
have multiple (IDEA)-projects with multiple modules you want to integrate in
Eclipse. The only solution I've found is to use separate work-spaces. But
then one has to reconfigure all the short-cuts, because they are bound to
the work-space. :(
Tom
Especially if you require the Eclipse user to first install the needed
plugins ;)
Charles Eubanks wrote:
I completely agree with this - although Eclipse (and Netbeans) provide
separate workspaces with related projects, as said, I like the
project-modules concept much better (although I cannot really give a
technical reason for this).
regards,
Messi
Tom wrote:
We have a couple of applications, each with a lot (~60) modules. A lot of
modules have the same name in each application, but correspond to different
states and - of course - locations on the hard-disk.
Since a major part of these modules have the same name, we cannot put all
our applications into one Eclipse work-space. Instead we either need to use
different work-space (which drives me nuts when the short-cuts are changed
to be IDEA-like) or first remove all modules of the previously used
application and (re)import all modules of the next application...
Conclusion: the project handling is much better implemented in IDEA than in
Eclipse.
Tom
Hello charles,
Nice idea... But...
First of all, this competition cannot be fair anyway. JetBrains developers
know all the features and nice usability tricks in IntelliJ IDEA, so they
are really experienced users. Of course, we know about Eclipse features,
but we are far from being "experienced". Inevitably, everyting will look
faster in IntelliJ.
You can say that our marketing is too fair for ... hm... marketing. But anyway,
developers are not so easy to cheat :)
Best regards,
Alexandra Rusina,
Technical Documentation Team Lead
-
JetBrains, Inc
http://www.intellij.com
"Develop with pleasure!"
No, seriously, find an experienced eclipse user -- it can't be that hard to find one. If necessary put out an advert for someone and offer reasonable pay.
Make sure the eclipse user knows all the keyboard short cuts and let him/her use whatever plugins are available -- even non-free ones. I have seen and used the latest and greatest plugins for version control and for web technologies. Even with those installed and an experienced user I think you guys win on shear avoidance of crappy dialogs and extra mouse movements. And the video would make this tangible to the eclipse crowd.
The hardest thing perhaps in this task will be picking a scenario where its a fair -- eg anyone can see that eclipse's javascript support is retarded so you can't make that a large part of the scenario. (probably stick to straight java and J2EE development stuff mostly)
And going through the exercise would be very educational in any case.
Marc Stock schrieb:
Immediately knowing what files/classes/methods are affected (show error
markers) by some modification is IMHO a really nice feature.
However much more important is Eclipse JDT's feature to incrementally
and partially compile the source code. This not only speeds up
compilation of larger projects it also helps because you can actually
run tests for incomplete or broken code.
With IDEA, I've quite often the following situation: I'm hacking on some
code and a co-worker comes and asks a question and I'd like interrupt my
current work and try some other code... now I cannot run that other code
because IDEA insist on me fixing my incomplete code at least so much
that it can compile everything. That's annoying.
The new Eclipse "API aware refactoring" feature might be a nice idea - I
haven't used it. It refactors but keeps the old method as a deprecated
delegate for backward compatibility in just one simple step. Otherwise
the new Eclipse 3.2 JDT features are mostly catch-ups with IDEA. I
really like that Eclipse already supports JUnit 4. It seems, even IDEA 6
will lack that feature.
--
Stefan Matthias Aust
Hello Stefan,
SA> The new Eclipse "API aware refactoring" feature might be a nice idea
SA> - I haven't used it. It refactors but keeps the old method as a
SA> deprecated delegate for backward compatibility in just one simple
SA> step.
I don't know all the details about the Eclipse functionality, but the "Change
Method Signature" refactoring in IntelliJ IDEA had the option to create a
delegate for a few years already (maybe even since version one).
SA> Otherwise the new Eclipse 3.2 JDT features are mostly
SA> catch-ups with IDEA. I really like that Eclipse already supports
SA> JUnit 4. It seems, even IDEA 6 will lack that feature.
JUnit 4 is already supported in current Demetra builds.
--
Dmitry Jemerov
Software Developer
http://www.jetbrains.com/
"Develop with Pleasure!"
Dmitry Jemerov schrieb:
So this feature is also just a "catch up" - good to know ;) I never
percieved the "Method calls Modify / Delegate" radiobuttons in the
"Change Signature" dialog...
Great. Didn't saw an announcement in the changes document.
--
Stefan Matthias Aust
The reason I use IDEA is because there has been put much effort into usability. At my work place Eclipse or RAD is the standard which everybody (except me) uses. When I occasionally need to open Eclipse, I always get annoyed by the fact that there obviously has not much emphasis on usability when Eclipse was designed. Here are some of the points I've noticed:
1. "The file has been modified. Do you want to save it?" Of course I want! When press the button to I compile or run the project, is there any use case when I would not want to save the file? In fact, I want the files to be always saved and that no information is lost under any circumstances.
Because computers user volatile memory, there is the need to synchronize data from memory to hard disk. The reason why many programs have save buttons, is that the developer of the program has taken the easy way, and left the full responsibility of disk synchronization to the user of the program. From the usability standpoint, the program should automatically save any modified data, and always offer the possibility to return to any previous state (see http://www.cs.helsinki.fi/u/salaakso/papers/CHI2001-Problems-with-Save.PDF).
IDEA's local history and autosaving (both enabled by default, although it would be good for also the "if application is idle for 15 sec" to be enabled by default) are a good example of how the save problem should be solved. Even though Eclipse has similar features, they must be manually enabled from the settings, which means that most users will never enable them, and they don't even realize how bad the usability is, because they already have pressing Ctrl+S as an unconscious reflex. An even if you enable them in Eclipse, the usability of its version history is not as fine tuned as IDEA's - last time I tried, in Eclipse it was not possible to undo a single line/block from between many other modified lines, but IDEA on the other hand always has a small button next to every modification, which allows you to undo only that block of modifications.
2. Seaching for text from multiple files. When you search text in IDEA, the search results show the line which matched the search. Eclipse only shows the names of the files, and requires you to click the file to open it in the editor. This means that when you make a search which returns results from many files, the Eclipse user needs to click every file in the search results, to find that one line he was looking for. The IDEA user on the other hand just needs to scroll down the search results, and will find the correct line quickly without the need to click files open.
3. The tabs of opened files. It took me actually more than a year of using IDEA, until I noticed the brilliance of IDEA's tabs. I never before had even paid attention to how the tabs work. IDEA has a maximum of 10 files open, after which it automatically closes the oldest one. So you will always see the files which you are actively working on (and going to a file which is not open is fast with Ctrl+N, so it doesn't matter if some old tabs get closed). When I used Eclipse a couple of weeks ago, I noticed that it keeps every file open, and the extra tabs are hidden in a drop down menu. So navigating between tabs in Eclipse is slow, because you can not see all the tabs at the same time, and it requires multiple clicks to go to another tab.
4. Update/commit files to/from CVS. Updating files from version control is one of the most ofter used operations in programming. However, Eclipse has no hotkey for it (if I remember right, I did not even find an option for assigning it a hotkey), but it requires selecting all open projects in the workspace (click project view, Home, ShiftEnd), right-clicking, moving the mouse over "Team", waiting 200 ms for the submenu to open, moving the mouse over "Update", and finally left-clicking. And the same thing for commiting files. With IDEA it's just a matter of pressing CtrlT for updating all modules in the project. Commiting is CtrlK, (write a comment), CtrlEnter.
When I've been lately working on the same project with one Eclipse user, there have been some occasions when he did not remember to commit some file to CVS. With IDEA this could never happen, because when you use the commit command, you see all files which have been modified. Using version control in IDEA is so easy, that an occasional update and commit becomes almost as automatic as pressing Ctrl+S is for Eclipse users.
Here's a tip I always like to share with everyone: set maximum tabs to 1, and "recent files" to any number you like; now, use CTRL+E (recent files) to switch between files. This is particularly great when you're working with a couple or more tightly related files: IDEA orders the recent files list with the most recently used file on top, which is exactly what you usually want.
Your workflow will be like: code in file A, press CTRLE, Enter, switch to file B; code in file B, press CTRLE, Enter, switch back to file A, and so on. I can't live without this anymore, and it's the single missing feature that makes my pain level skyrocket when coding outside IDEA.
Another thing I miss in Eclipse is IDEA's CtrlShiftF7 highlighting of the
element at the caret. Eclipse has two similar, but IMHO not that good feature:
1) you have the possibility to search for references, but this destroys your
(other) search result output,
2) by default it highlights the object at the caret which annoys for normal
work.
While we are at searching: in IDEA it is much easier to switch between
multiple opened searches.
Regarding searches there is just one feature I miss in IDEA: IDEA should be
possible to highlight search results (e.g. Find Usages over the full
project) in the file.
Tom
The main reason I have heard as to why people (at least the ones I know) chose Eclipse over Idea is because eclipse is free and Idea is not. I personally think that it is the wrong way to look at it because I think Idea is a better IDE and the folks I know who use eclipse don't say that eclipse is better (actually what they say is tha "Eclipse is as good as Idea", which supports the point you want to make with the video), but they don't want to spend money on something that they can get for free, even if it is better.