I honestly can't understand why anyone would use Eclipse when the community version of IDEA exists, but hey.
Often they say Eclipse sucks, which is completely ignoring the question, and usually doesn't come with any substantial explanation of the supposed suckage. Moreover, talking about how one thing sucks and then silently comparing it to something else implies the other thing has no flaws, which is clearly unfair and stupid.
The only positive non-eclipse-hating arguments I've heard is that it's "easy to use" or "slick", both of which aren't useful to me since I'm familiar and comfortable with Eclipse's user experience. The rare time a feature is mentioned it's something Eclipse has as well.
I've tried to learn it a few times but since no one has been able to articulate any good reason to use it past a kind of anti-eclipse zealotry I haven't spent more than a few hours on it.
I'm not saying it's stupid to like IDEA, I'm saying that I think that preference in this case comes down to wishy washy things like 'feel', which is entirely subjective and entirely inarguable.
I will say this, I've heard plenty of IDEA users be snarky and condescending to people who use Eclipse (I've recently changed jobs and now work in a place seething with them), and I've not once seen it the other way. Anicdata I know, but that is life.
Stuff like what comes first in autocomplete (Eclipse's quality in this regard has been somewhat inconsistent). Refactor suggesting intelligent names for variables based on their types.
And then there's the theming. Normally, Swing apps are somewhat ugly and generally obnoxious. The JetBrains folks have put together a Swing LaF that's beautiful and compact, which also contributes to the overall experience just being pleasant.
I'm happier using IntelliJ.
For example; for some reason Flash pretty much always crashes when you're pausing the VM (stepping through commands) for too long, but it's impossible for the IDE to detect that.
That meant that every time this happened you would need to first stop the debugger and start it again. In IntelliJ IDEA 12, only for Flash, the debugger's start button now turns into a 'restart' button which does just that in one click.
It might be a tiny detail, but somebody actually looked at my specific use case and added an improvement for it which is quite an amazing level of attention to detail.
When you see this on the first run, it kind of successfully undermines the argument about ridiculous attention to detail. I know that Swing is not under JetBrains' control, but Eclipse looks fine.
http://stackoverflow.com/a/12976496 shows me that they aren't using native font rendering.
http://blog.jetbrains.com/webide/2012/10/phpstorm-webstorm-5...
Your belief appears to be that things you have a hard time noticing, like "feel" and "ease of use", are entirely subjective.
That's definitely not true. You not seeing X isn't proof that X doesn't exist. Germs are too small to see, but they matter a great deal.
The same is true of usability. You can definitely measure it. It isn't subjective, but it is personal. Even so, it still matters, because those personal factors have a lot of regularity across individuals that can be exploited. A great example is the iPod. It wasn't the first MP3 player, and it arguably wasn't the best when it came out. But it crushed the existing players because Apple spent a lot of time on making it easy to use and slick.
The amazing thing to me about the iPod isn't that it was better than the competition. It's that the competition never caught up. Precisely because, like you, many of their engineers and executives never took usability seriously.
IDEs are interesting because you get very used to the one you're using. I am much faster and efficient in Eclipse than I am in IDEA (I've used a few times over the years, for about a day each time).
Could I become faster and more efficient in IDEA that I am at Eclipse if I spent a month learning it? Maybe, I don't know. No one has made any arguments convincing enough for me to sink an entire month into finding out.
If I were able to set up global Maven build configurations without having to jin up a dummy parent project, I'd make the switch. IntelliJ has superior support for running and debugging individual JUnit tests and application debugging in general.
I also like the ability to set up a variety of "runners" in IntelliJ and then execute them with a fuzzy find as if I were on the command line.
I typically have a projects directory under which I have many subfolders containing Maven projects. In IntelliJ I create a single module rooted at my "projects" folder but for this module do not set up any sources. Then it is just a matter of right-clicking any POM and selecting "Add as Maven project..." I can enable/disable these projects at whim.
You can also simply add each module at a time.
I've always been impressed that it "just works". It'll even do in-IDE compilation against latest sources if it detects a snapshot dependency across (even non-nested!) modules/projects.
This was back in the Eclipse 3.5-3.7 days, but with 4.x already out, it's possible that this issue has already been fixed.
Then there were plugins you might want but they were only distributed as Eclipse installs so you either had to install that version or download it and steal the plugins you wanted out of the directories after you unzipped it.
Once you got it running it wasn't much of a problem, but it was one of those things that I hated dealing with the few times it was necessary.
1) Inability to automatically import types within a project the way java projects can means I have to manually enter all my import statements. No productivity increase over a plain text editor there.
2) Autocomplete bugginess. Sometimes deleting text too quickly causes the autocomplete to have fits, and I end up watching a single character deleted every few seconds as it struggles to catch up. On a 2012 MacBook Pro with 16GB of RAM under light load, this is terrible performance. Again, a plain text editor works better.
3) Hit-or-miss (mostly miss) ability to evaluate Scala expressions while debugging.
4) Occasional error-recognition bugs. Sometimes the IDE will insist something is an error. Compiling the code will work, and after I close and reopen Eclipse, it agrees that there are no errors.
5) Constantly fighting with out-of-sync issues with the file system. Roughly 50% of the time that I click a file to open a code-editing window, the code editor window will simply say, "Out of sync with the file system". I then have to hit f5, which sometimes works - sometimes I have to refresh the entire folder above that, or its parent, or...etc. This happens even when there are no external programs editing the file in question.
None of these things truly prevent me from getting my work done, but they slow me down and are irritating.
For software I use a lot, I find learning in bursts works well.
On first use I have an initial explore until my brain starts to overload and then just try to get stuff done.
From then on, every so often - perhaps a month later and even a year or years later, I'll go on another exploration session to build on top of what I know.
If you've never done it, it's worth trying. It worked wonders for my vi skills many years ago!
If you have never seen this feature of Eclipse, I encourage you to try it.
Which personally I think was a waste of development time, I cannot imagine how it could be useful to keep compilation errors in your code.
As for the merit of the technique - try it out. I've found it allows a level of experimentation not possible without the option; personally I've found that useful when it is not obvious what the right thing to do is upfront, I can try out a small change to a chunk of code, try it out via unit tests, then update all call sites appropriately; as opposed to attempting to "upgrade" call sites appropriately using a canned refactoring before I've validated whether or not I'm going to be able to achieve what I want for a few test cases.
I bet it has improved loads since I last used it, and hopefully my brain would deal with it better, but I live in fear of ending up in a situation where it is mandatory to use it and I had to take the job for financial reasons. Well, living in fear is an overstatement. I'm sure I'd learn, with a kind of weary resignation and resentment.
Has anyone been put in such a position? The only times I've since been put in a place with loads of Eclipse where you have to use locked down client machines such as financial institutions, I've just said, I need Intellij, and it has been fine, thankfully.
IntelliJ might be a tad better usability wise, but Eclipse has so many extensions, tools and more as it is the default IDE for a lot of projects/ecosystems.
I think it is a matter of preference, and what you are used to.
I think Eclipse is fantastic these days, enabling rapid navigation of huge codebases and helping me to understand unfamiliar code. The refactoring tools are also fantastic and I use them constantly, ie. regular development includes frequent refactoring.
But I'm sure I'd be really happy with IntelliJ, too. I still think it looks a lot better, Eclipse could really do with a drastic facelift; the most recent release just makes things worse.
I'm not usually inflexible, I'm happy flipping back and forth between very different development environments usually. As we've seen there are people who feel just the opposite as me in the thread too, no doubt it is partially down to how one builds mental models and how well they fit the abstractions chosen in both IDE's for various concepts.
Can you provide a link to a guide going over some techniques for using Eclipse to its potential? My inability to rapidly navigate large code bases using Eclipse is one of the reasons I dislike using it so much - I usually end up grepping in iTerm instead of trying to use Eclipse to search.
Call hierarchy (Ctrl-Meta-H?) is fantastic; it works on everything, not just on methods. Press it on an object's field finds all methods accessing it, and all methods calling those methods, etc. You can expand the tree at will and jump around the code. It's smart enough to deal with anonymous classes definition and access. I think it's hard to overstate how useful this is. Find references (Ctrl-Shift-G?) I hardly use anymore because call hierarchy is basically a functional superset, but it's also fantastic.
Class hierarchy is hardly exotic, but it's still useful.
Ctrl+click/F3 jumps to declarations (and implementations for interface methods). Also hardly exotic, but you simply use it all the time in lieu of more regular navigation. On a sidenote: while debugging, ctrl-shift-click runs the paused program until it steps into the selected call, moving the editor to the line.
Within files, usages of the variable/type/exception are highlighted, and you can jump between the positions using the keyboard. They are also highlighted in the scroll bar, so you can immediately see if this field is used just once or twice, or everywhere. Also within files, Ctrl-O opens the file's outline, letting you jump to methods, types and fields using the keyboard.
I'm sure I'm forgetting some and there are other tools I don't know/appreciate yet. The only time I use grep in the Java projects I'm working on is when I need to deal with resources. In my pet javascript projects, OTOH, I use :grep constantly (feeling super clumsy all the while). I looked at the transmission code (which is C) on the weekend and I almost went insane because I had no kind of introspection/tooling initally (later on, ctags improved things somewhat).
For me i only need the following to zip through a sizeable code base with just a few key combos in eclipse:
* F3 - go to definition of thing under cursor
* ctrl+g - search for all usages of thing under cursor (used sparingly, too slow)
* ctrl-shift-t - find & open type
* ctrl-shift-r - find & open resource (these 2 should be merged!)
* ctrl-e + start typing the name of an open window to switch to it
* ctrl+shift+F4 i'm in too deep, close all open editors
* ctrl+/ fold all methods, i never warmed to ctrl+o or F4 for an overview of the code in a module / class
I have a couple of non standard bindings i set for things like show me the version control log for this file.
It all falls apart when you want to navigate within an editor a-la vim motions.
nope - still dead - http://plugins.intellij.net/plugin/?id=1373 http://youtrack.jetbrains.com/issue/IDEA-
(also, the very latest eclipse looks really clean - i was surprised and impressed when i started it up the other day).
Structural search & replace
In general, Eclipse works pretty good. And it looks incredible when compare to NetBeans and other free IDEs.
2. The editor and other UI widgets (proj/file trees) provide a lot of information on the state of your world via various decorations. Example - you have a Java file open. It has compilation errors. Those errors will be highlighted in the "overview" margin. This shows as colored marks on the side of the editor. They are used to quickly navigate to different things. This specific example are called Annotations in eclipse parlance. The same decorations are provided at file and project level. So, at a glance you can see if project has errors and as you drill down, it's easy to locate which dir/package has errors, etc.
2a. If you put your cursor inside of a variable, type, etc it will highlight all instances/references of said thing in the overview margin. super handy.
2b. The same goes for CVS annotation (or more general "team" annotation). Even though this is buried in my list, it might be my favorite feature. You get line by line annotations (colored by age) and you can link this margin to a history window. Click on an annotation to see full history entry in window below. Killer.
3. Useful commands: CTRL-SHIFT-G (find occurences) and CTRL-t (open type), CTRL-r (open resource), CTRL-o (open field/method) and .... i forget the key sequence but the command to open class heirarchy. Those are my main ways to navigate. Open type/resource takes wildcards. Use them.
4. All of the above allows me to work with a reduce UI, sometimes, many times in full screen mode.
5. Understand that Eclipse uses it's own compiler. If you compile outside of Eclipse (ant), then those class files are thrown out and recompiled when eclipse is run again. You can get the eclipse compiler as standard jar and it works great with Ant and the like. If you have a mixed environment, then you def need to look into that.
I used Eclipse at my previous job. I do kind of miss the perspectives thing, that was a nice organizational tool once you got used to it.
If you are happy with what IDEA delivers out of the box, then it is probably the best for you. Otherwise, I would should just stick to Eclipse because it offers better options in general.
Then of course there's the obvious reason that with the community edition there's no appserver support. Eclipse has that.
At this point I'd use eclipse if I was familiar with it. I'm just too used to the key mappings of IDEA to deal with the switch over.
One of the main features of this release (version 12) is the upgrade of the Spring integration, so maybe IntelliJ will become useful to the Spring Java crowd.
Note that the community version of IntelliJ doesn't have this Spring support (nor the javascript IDE capabilities).
But thank you for your condescension.
It has much, much better plugin support e.g. AWS, Google CodePro. If you use the slightly older version then it is an order of magnitude faster than IntelliJ and generally works much nicer on OSX. It is also less cluttered meaning more room for code for those on laptops.
Also IntelliJ's indexing of files on startup is completely insane. It maxes out my CPU for at a minute or so which is never good on a laptop.
IntelliJ is nice and I use it at work but it is hardly some amazing piece of engineering that its supporters love to tell me it is. In fact I have found it to be generally quite buggy.
It might be worthwhile to give it a try just for that feature alone.
On the Core i7 Windows laptop box I use for work, it fell into that "OMG, how can anyone use this?" category and I'm still using Indigo.
Google "eclipse juno slow" and you'll see a ton of hits. I know they've been taking steps to address this partly by using funds Google donated to Eclipse for the purpose of having more test machines to deal with this specific issue, but I haven't had a compelling reason to see if newer releases of Juno really fix the problems for me.
I use IntelliJ every day, and I've found it to be fantastic. When I switched about two years ago, I was happy I switched within a few days (although at this point I don't really remember why I found it to be so much better).