I can't tell if we're being punk'd. I'm expected to take that screenshot as an example of a less distracting user interface for creative work? My condolences to anyone using the presumably more distracting previous version.
I found it obvious that the new screenshot was showing off the dark theme. I found it far less obvious whether they expected to it to show a "more clean and functional" interface.
As a person who suffers from black floaters in his eyes the black UI elements are always welcome. The elements by themselves might not be less distracting but they make my floaters a lot less distracting.
That's a debugging view on a really small window. The bottom panes only show up while you're debugging and the left pane is your project browser, which you can show or hide with Ctrl-1 or Cmd-1 depending on your OS.
I use it at 1680x1050 on my rMBP and it's fantastic.
The screenshot shows a debugging session. Both the debugging panel at the bottom and the project panel at the left can be collapsed. So it's not that bad.
But in general, yes, i agree in that Intellij IDEA's interface is quite overloaded. I haven't tried any language-specific version of the IDE, like PhpStorm or PyCharm; maybe those are less loaded, IDK.
Yeah, I use Intellij daily, and the UI is quite poor. Little things like the way tabs work, the way the debugger buttons are inscrutable, the way that the vertical splitting works with opening files using the C-S-n shortcut, etc are quite annoying.
It's redeeming quality is that the only worse UIs are every other IDE. (Expecting perhaps Visual Studio, which is not a viable option for non-MS shops)
You just completely and utterly missed that it's a 950x570 screenshot (so essentially a stamp) during a debugging session with the visual debugger taking the bottom half of the screen.
No, I caught that. I just honestly don't think what's witnessed in that screenshot would be repaired by a screen of any resolution. It's a UI/UX tragedy of a severely high order.
I honestly can't understand why people love IDEA so much. I know lots of people who swear by it, but absolutely none of them can articulate why.
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.
Ridiculous attention to detail. It isn't the big things, mostly, that draw me to IDEA (though some of them, like the way it handles projects and that Maven Just Works, help a lot), but the thousand little things that someone, somewhere, got right that you don't think about. Unless I think about it, I just notice that the overall experience is somehow more pleasant.
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.
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.
Well, it is a Swing app and Swing apps on Linux look atrocious. Especially the font rendering looks like taken from Linux distributions from 10 years ago.
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.
IntelliJ used to look quite a bit like a Swing app. At least on OS X, going from 10 to 11 was a major visual improvement. You can tell it's not native, but it's MUCH closer than it used to be.
Hmm, I don't use Linux myself so I can't really be 100% sure. But I found the info here. Maybe they don't mean "platform rendering engine" when they say "system fonts"?
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.
I'm sorry if I confused you by using the term subjective. You're right, I meant personal. And I certainly care about usability, my point is that no one has ever been able to convince me about why IDEA has better usability, or if the supposed usabilty improvements are things I'll care about.
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.
Usability, in fact, is why I prefer Eclipse to IDEA. I've tried IDEA before but it always felt like a Swing app. From the obvious, like the way file dialog works to the subtle, like how the UI reacts, makes Eclipse feel more usable to me.
Eclipse's Maven support is not great. IntelliJ's is better but Netbean's is the best in my opinion. The problem with IntelliJ's Maven support is it doesn't handle multiple non-nested projects well.
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 use IntelliJ with multiple non-nested Maven projects all the time.
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.
I had issues with updating Eclipse itself. The last time I used Eclipse was when I updated the main IDE itself. The update somehow broke my plugins (including Google's ADT) so badly that I had to remove Eclipse and reinstall it and the plugins from scratch. I decided to move on to IntelliJ after that, and I have not had any update issues since then.
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.
I've been out of the Eclipse world for about two years but that was always something that confused me. With Eclipse it was also so hard to find the right version to download. You couldn't download Eclipse, you downloaded the Something pack or the Other Thing pack.
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.
I find Eclipse's Scala support to be somewhat lacking. Don't get me wrong, it's usable. Apparently it has come a very long way...before I began doing Scala dev, I guess it was really rough. Still, there are enough annoyances that I typically find working in vim more productive.
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.
IDEs, no matter which vendor they come from, are complex things. A zillion options, keystrokes up the wazoo. Moving from one to another is like having an arm lopped off. It takes a lot of time to get comfortable. Muscle memory is a powerful thing.
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!
One thing I miss from Eclipse, for Java development, is the ability to run unit tests (or a whole program for that matter) while compilation errors exist in the code. Intellij forces me to make all my code compile before I can try out anything - I believe I do less iterative development and make less exploratory changes to code when using Intellij because of this. I've found I can live with it, and do, because my team uses Intellij, but I sure do miss executing code that won't compile.
If you have never seen this feature of Eclipse, I encourage you to try it.
I tried it out, you can now make an Eclipse like experience, albeit requiring many key presses to invoke compiliation and execution of code. It's not as slick as Eclipse, but its possible.
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.
A few years back I started doing work for a company where Eclipse was the standard (familiar huh!). I spent six weeks feeling like I was an unproductive failure until I gave up and unilaterally decided that I had to go back to Intellij otherwise I'd go insane. I really tried. It didn't seem to be built to work in the same way my brain did.
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.
I have been in the oposite position, where I came from Eclipse background, and had to use IntelliJ. Lets just say that I wasn't a happy camper for a while.
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've been in exactly your position. I was a huge fan of IntelliJ IDEA, to the point that I raved about it in the (very informal) interview. They were using Eclipse. Adapting wasn't all that difficult for me, much more stuff is similar than different between the two.
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 really should take it for a spin again and find if I find it as intolerable as I did then, as an exercise in keeping flexible.
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.
> enabling rapid navigation of huge codebases and helping me to understand unfamiliar code
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.
I don't really know of any guide, though I'm sure they are out there. Briefly:
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).
I was in that position 5 years ago. I really tried - spent time learning keystrokes etc. What got me was the lack of integration and lack of basics. For example, Find Usages and Search were incredibly crap - which is a major problem when you've been brought onto a new project and you need to read and understand the code base. Perhaps things have improved since then. Ended up installing IntelliJ on the sly (advantage of a personal license!)
has the c plugin been resurrected? last time i looked, it was dead. which is a pretty major gap in an ide (i buy each release of intellij idea and use it for python, java, clojure, but i still switch to eclipse for c).
hi - i've got the 12 ultimate edition idea and am trying to work out what plugin would contain the appcode functionality (my impression is that other intellij products are basically intellij idea plus a hard-wired plugin - pycharm is like the intellij idea python plugin, for example). but i'm having a hard time finding an objective c plugin. do you have any idea what it might be called? thanks.
AppCode is the exception to the rule. It's a totally separate app that only runs on Mac OS X. None of it's features are available in IntelliJ. (Having said that, a lot of the base IDE remains the same so the general UI and keystrokes carry over).
Do you know of any good guides on how to use it? I know it's there but the last time I took at look at it it looked like I was going to have to spend a bunch of time to figure it out.
1. Everything is organized around "perspectives". A perspective is a set of views organized to help you perform a certain task. E.g. Java (coding), Debugging, CVS, etc. You can customize any perspective as you see fit. I use Java and Debugging. They took me a while to get used to, but in the end it's a very helpful construct. Don't just make one huge 'everything' perspective. Instead throw them on hot keys (alt-1, alt-2) and just switch back and forth as needed.
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'm sorry, I meant the Structural Search & Replace in IntelliJ. It looks really handy but the one time I opened it I couldn't figure it out (I was busy so I didn't spend more than 5 or 10 minutes on it).
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.
I have used both IDEA and Eclipse recently. My opinion is that IDEA has very interesting tools, but when viewed as a complete platform Eclipse deliver the best experience. There are some things that IDEA does better than anyone else, but the editor itself is mediocre. For example, the UI is too complicated, and the tabs are terrible to use. The number of plugins is also much smaller than available for Eclipse.
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.
I use Eclipse simply because it allows me to have multiple projects open in the same workspace and search for files/classes across all projects. When Idea gets that feature I'll probably take another look at it.
I've seen a belief that because IDEA isn't permissively licensed it has ideological impurity and shouldn't be used. Perhaps people take that to the point of zealotry.
Everyone uses Eclipse/SpringTool Suite(STS) for spring/grails application development or for projects using gradle as a build tool.
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).
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.
I am not the parent poster, but I would assume he's talking about using Indigo (3.8.x) and not Juno (4.2.x). Eclipse took a speed hit with Juno. A hit which seems to vary depending upon your system from "a bit slower" to "OMG, how can anyone use this"?
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).
Same thoughts here... been trying to move exclusively over to IJ since 4.x series but two (really dumb) things send me back to Eclipse every time: Javadoc formatting and Web Project module support.
I mean "really dumb" in the sense that these things shouldn't be so important to me, but as someone who writes a novel's worth of documentation inside his code, subpar Javadoc formatting doubles my workload.
The project model thing is my own problem trying to mentally map the whole project/module/artifact abstraction IJ has... I don't understand it, never have, doesn't seem intuitive and mostly just frustrated me.
I think more of this has to do with the layout of the project properties dialog than anything combined with my own mental reluctance to understand what they are proposing here.
That said, the code quality of the product seems to be excellence. Very smooth, no surprise exceptions during use (Which is par for the course in Eclipse).
Some day I'll sit down and figure it out, but until then I will continue to be confused and stick to my simple, flat, POM-defined life in Eclipse and cry every time I load up 4.2 and wonder why I am doing this to myself (if you haven't used Eclipse 4.x series yet, you don't understand how much pain there is waiting for you).
Have you ever tried to import a project in IntelliJ just by opening the POM file? I find it imports the project structure from the Pom very well.
I agree that Idea makes it's project layout very hard to understand for beginners and struggled with it myself until I realized you could just import a Pom file and be done with it all.
> if you haven't used Eclipse 4.x series yet, you don't understand how much pain there is waiting for you
Wow. I thought Eclipse would have gotten better along the years. Back when I switched to IDEA at version 4.x, the difference between them was like night and day - IDEA was so much better.
Could you tell me a bit about the pain of Eclipse? It's quite surprising if they haven't managed to produce a solid IDE yet.
I agree that IDEA's way of organizing things is kind of clunky. In a way, a "project" can be thought of as "metadata about stuff I'm working on", instead of the more intuitive "a project is a directory on my hard drive".
Once you set up a project, you can then bring stuff into it with "modules". For example, you may want to include source code trees and/or JARs from multiple locations.
Eclipse is the non-commercial result of a committee of developers so wide and uninvolved in each other's greater visions and monetization strategies, that the user-experience of the base platform is "functional" at best.
I can cope with just "functional" (and stable) but Eclipse is "functional" only -- the core platform (UI, plugin framework, all core Java/source tools, etc.) are really stable and robust.
Everything else built ontop of them (custom editors/designers, Web tools, all of WTP, Maven tooling) basically all the ++ resources are unbelievably memory hungry (turn on the heap monitor and watch it when you run the Update Manager > Check for Updates... seriously, just watch how many objects are instantiated and GC'ed in that simple cycle, 100s of MBs) and generally broken.
To that point, the "design by committee" environment leads to overengineering that you cannot fully appreciate until you start trying to build ontop of those APIs. If you hate yourself, try and build something ontop of WTP from scratch (like custom tech support, like a Play IDE).
Also interacting with the Update Manager concept that has tried to become so much more but has been hammered into this "jack of everything-even-stuff-no-one-needs, master of nothing especially the thing it is suppose to do"
The intelligence needed to correctly calculate an update plan based on plugin versions and interdependencies is worthy of a PHD -- if you've used Eclipse for an extended period of time and upgraded yourself into a corner that the Update Mangaer cannot update you out of, then you know what I mean. If you are a long-time user you've heard "Try a new workspace" or "Do a new install" more times than you can count as far as trouble shooting first-steps.
Eclipse is an odd ecosystem. The only money to make by EVERY company involved is in +1 features that have not been commoditized by the platform.
Unfortunately these are ALL the developers contributing to the core platform, the same ones trying to keep their pay checks by developing tools ontop of the core. There is no desire to cannibalize their own products and markets by contributing that stuff unless they absolutely have to (for fame or strategic reasons, take your pick).
The move to 4.x was a total redesign of the platform to make it "Web friendly" I think, I have no idea... but it was a major-major overhaul of the core platform and the result is a buggy/slow/mess even at the core level that has long since stabilized.
Anything beyond "core tooling" available in the open-source bundle is going to be what I would consider a "best intention" implementation. Not good enough to put anything commercial out of business and not bad enough to be berated or ignored completely... just bad enough to make you crazy with rage if you depend on it day in and day out, but good enough to seem cool if you are doing a tool evaluation. That said the stuff that gets used by EVERYONE (e.g. Java code tools) is great because it is in every contributor's best interest to have that stuff rock (their day jobs). For the tooling that is very specific to a team or company, definitely not the case.
IJ on the other hand is a single product backed by a single company with the sole focus of being as-good-as-it-needs-to-stay-commercially-competitive. JetBrains has to spend money to convince people to spend THEIR money... the market is forcing this product to get better and better and those developers appreciate things like rewriting a plugin framework to keep it fast, rewriting the code-completion parser to update faster, etc... the kind of stuff that is huge technical debt after 8 years that an OS project can almost never justify sticking on someone's bottom line to rewrite.
That said, I actually dislike some of the core project paradigms used in IJ which is the only reason I don't swear by it heart-and-soul. The dev experience is much more stable, performant and consistent.
If you want a corollary of what I mean about "paradigms" consider the IJ UI builder compared to the NetBeans one -- NetBeans when NaturalLayout came out was all about "Drag and drop with snap-to rules" -- it was intuitive as all hell.
IJ on the other hand was all about FormLayout-like behavior and a way more technical experience with weighting and splits and bindings.
Both were pretty stable and worked great, but took very different approaches. If you bought into the IJ model it was awesome and you had a great time using it.
If you were like me and wanted the preferred-spacing snap-tos guiding your design, it was a pain and you much preferred the NetBeans UI designer.
So if you are doing core Java dev work, Eclipse and IJ are both awesome. If you are doing Web Dev/Spring/JavaEE/JSF work -- try them both, the bugs in Eclipse will eventually drive you crazy I imagine though and I am NOT saying IJ is better, it is different, and in some design/paradigm ways less intuitive in my opinion which is what keeps me from just recommending it to everyone I meet on the street.
NetBeans falls somewhere in here... I think in a lot of ways it is an unsung hero, has some nice polish that the others don't, very human friendly but is also missing some hard-core functionality that you find after about a month of use in my experience. Back in the day the real-time compile and auto-complete speed of Eclipse kept me away from NetBeans. The "based on Ant/maven" building design was a decent call I think, I get why they made it when they did, but it did cost them some things.
The NB team has shored up the editors quite a bit so I think most is caught now during editing. I am meaning to try the 7.2 beta so maybe I'll be happily surprised.
I haven't used the last 2 versions of NetBeans though -- the Javadoc formatting always moved me away from that one as well.
What a silly reason, I know -- should stop writing so many comments :)
Your description of Eclipse hits the nail on the head. +1 For the comment on updating yourself into a corner. Eclipse plugins make it insanely easy to shoot yourself in the foot and get the IDE into an unusable state. Eclipse has an amazing variety of plugins, but sadly 99.9% of eclipse plugins give the other 0.1% a bad name.
From what I've seen many folks have started using IntelliJ due to the top-notch Scala plugin which Jetbrains provides for free.
I love JetBrains - those guys know how to build a product. I'm particularly interested to see how this starts to affect the other products like PyCharm, RubyMine, etc.
As far as I can tell, the changes from IDEA 12 are already making their way into the EAP builds of the subordinate IDEs. Certainly it seemed that way from the most recent PyCharm EAP announcement:
I've tried IDEA briefly a few times but what gets me is the lack of an error pane that's as compact and descriptive as the one in Eclipse - the pain of using Eclipse 4.x is tempting me to ignore that limitation, however.
I know it's possible to get some of it with inspections but what I really want is something that combines errors+warnings together and gives me instant feedback. Am I just missing something that's really there?
A million times this. Your screenshot doesn't show it, but Eclipse's error pane shows all errors and warnings from all source files in the project. This is very useful and not possible in IDEA or NetBeans. So it's easier to overlook errors and I never have the same feeling of knowing about things that need attention in my projects.
God i love the phpStorm IDE so much, I was a user of the text editors for a while. But the debugging support in this ide for PHP is just amazing. It integrates with mercurial nicely too. The recent black color scheme is just a nice surprise. Well worth the price.
I've been using the Android UI editor in IDEA 12 EAP for quite some time and it's been really pleasing to use, especially for a first release of such a complicated component.
[OT] It is, however, very stupid and frustrating that an IDE has to recreate all the Android drawing and layout engine just to show a static view of what your screen will end up looking like. Compared to the experience of web development where you can edit the living DOM model and see the changes in real time because there's no difference between coding time and running time, the Android UI experience feels very arcane :(
Since you have obviously used the new version, can you comment on how compatible it is with projects created in v.11? Do we have to recreate the entire project, or will it import them as-is?
I was able to use it at the same time I had IDEA 11 up with both using the same project. It was interesting. Every time I'd switch to the other IDE window, each one detected some changes to the project structure and wanted to reload it.
Otherwise, it was very transparent. No pain at all.
Could someone please comment support for Clojure ? The last time I tried , I did not find La Clojure to be any better than Eclipse + counterclockwise .
No harmt meant but I'm SCJP since more than 10 years and have been both a long time IntelliJ (still have IntelliJ version 4 installation files backups on CDs, found them yesterday) and a long time Eclipse user and I'm now using Emacs.
I know, I know: Spring, refactoring, ORM + XML hell and whatnots for hundreds of K's codebase of 'enterprisey' stuff doing really not much...
But as a now long-time Emacs user (since a few years) watching IntelliJ vs Eclipse fight looks a bit like like Lada vs Yugo car owners fighting about who has the best car ; )
Whatever floats your boat. I bet you would be happy using notepad to write Java too. Eclipse might be Yugo, but using Emacs to write Java is like using Fred Flinstone's car. Hope you got thick callouses ;)
Yes!
The compiler now runs in a different process from the main IDE. This actually makes a huge difference. Interacting with the editor is now instant, projects compile faster, and the IDE uses less memory. For more details:
http://blogs.jetbrains.com/idea/2012/06/brand-new-compiler-m...
(Above screenshot: http://blogs.jetbrains.com/idea/wp-content/uploads/2012/12/d... )
I can't tell if we're being punk'd. I'm expected to take that screenshot as an example of a less distracting user interface for creative work? My condolences to anyone using the presumably more distracting previous version.