Hi, I've been using jdeveloper 10g for almost a year now, coming from Eclipse I must say that I hate jdeveloper. It's counterintuitive, heavy, slow and have poor quality plugins, like the subversion client.
Eclipse may seem more complicated to use for a beginner, but that's because it's also far more configurable than jdeveloper, has better plugins and doesn't force you to do weird things with the project structure.

Netbeans is just more intuitive than Eclipse. For beginners, netbeans is definitly the best option. Its easier to handle projects, easier to get 'up & going'. I do tend to belive that IntelliJ is in a league of its own, but it is costy. For my own 'home project developments' I use netbeans, and intellij at work.

Being new to the whole netbeans eclipse thing, and a new Java programmer, I tried eclipse first and I was impressed, until it stopped working for no reason. Netbeans not only includes an GUI editor and doesn't have to rely on dodgy plugins, it works!

Eclipse is the absolute winner in making plugins and other RCP stand-alone stuff. But it's so complicated, boring and hard. Sometimes i was going mad when tried to configure the build path and other output paths.
I find that NetBeans is much more dev friendly but there is a lack of functionalities.
It's sad to say, but there is no perfect IDE

How does everyone rate Netbeans 5.5 against JDeveloper 10.1.3?

Too many people are complaining about Matisse guarded code block. But I think it is a good way to separate UI from data and logic. In software engineering process, this is good habit to separate them just like MVC pattern. So I don't think it is a disadvantage. I think 90% of GUI programs don't require too much customization code. Even if it does need, most of customization can be resolved by the code panel of property sheet. If it cannot satisfy your need, I would suggest you not to use Matisse to build it. Why not manually write it?
So in all, why not use Matisse to build 90% 'normal' GUI programs and manually write the 10%, which need too much customizations. Matisse guarded block can be seen as an advantage over hand-written chaotic code generator.

These are somewhat early impressions, and are entirely personal opinions (and your mileage will surely vary, and we can agree to disagree), but ...

(1a) Matisse GUI builder is nice, so long as you don't need to attach a DocumentListener to any JTextComponent objects ... and then you're adding the code by hand. (The same issue apparently exists for any event fired by some instance member inside your component.)

(1b) Can't directly get access to non-beanified things like the Box class components (glue, strut, etc.).

(1b) Seem to need to write custom code to attach a non-default list model (etc.)

(1c) Also rather forces a top-down monolithic approach to building the GUI just to let the connection mode do anything worthwhile. That is, if you create individual panels, add them to the palette, then build them into a larger panel or frame, you can't access the sub-pieces in connection mode. (Or at least, I never saw how to.) Granted, events can still be wired otherwise, but seems to defeat the existence of this 'mode'.

(2) On the same hardware (512MB RAM) and on the same project of files, eclipse stays far ahead of me, while Netbeans drags behind me, performance-wise.

(3a) Eclipse editor has a right-hand gutter that visually shows all the places the currently selected variable is used in that file. (and where comments are, and ...) I couldn't find whether Netbeans offers that, but certainly not out of the box.

(3b) Behavioral gripe: Pressing 'space' at certain times in the netbeans editor does code template replacement... I suppose I should apologize for using one of netbeans' many 'magic strings' as my own variable name. It seems that 'shift+space' would be a more sensible default setting for this behavior -- yes I found it in the preferences. The message here is that, as a user, if I want a special action to take place, I'll do something special to get it. Hitting space bar when typing in code is a long way from a special action.

(4) Eclipse auto-compile is rather nice. This is its own holy war, but when I mis-type code in Eclipse, I get immediate feedback about all the other classes that just got borked (and it happens *fast*... see point 2).

(5) Netbeans provides no 'File - Import' feature? I have to step outside the IDE to copy the file in myself (or do the equivalent via the Favorites window, which seems horribly misnamed), meaning I have to navigate the file system twice: once to find the file, again to find the package I want to drop it into. Then, I have to update the package and import statements. Eclipse makes this a zero-think operation. right-click package, import, find file, everythings done and the project's status reflects this (see point 4).

(6) On a Mac, Netbeans throws up the CFMachPort (?) error message when I have it run my app. While you can conspire to make Eclipse do that as well, it doesn't happen normally, whereas it does it every time with Netbeans.

(7) On the other hand, if you want out-of-the-box capabilities for JSP work (etc), netbeans looks like it probably beats Eclipse ... but I don't do a lot of work in this area to make a solid judgement.

So, point #7 [possibly] notwithstanding, the 'features' that are present in netbeans seem self-incomplete in just about any area I encountered ... and this was while trying to use netbeans for its #1 feature: building a Swing app with the GUI builder. I'll probably still use it to layout the panels and frames (unless matisse can be decoupled and used independently) but I'll certainly import the files over into eclipse to work on the real business logic. To each their own.

i have been using Netbeans on a Windows box for over 18 months and the stability is fine.

Umm... It's fine if you ignore the 512Mb of RAM recommendation.
Start with 1GB and more won't hurt.

It's the memory people!

Inadequacies of Eclipse:
Eclipse presents a tool/functionality-centric view to the user. Netbeans provides a programmer-centric view. For example, Eclipse puts project building as an 'external tool'. A programmer would view buiding/compiling as an integrated aspect of an IDE, but for Eclipse, g~d knows that you had to step into a menu called 'external tools'. If you want to create a project containing JSPs don't create a J2EE project, but create a Dynamic Web project - remember Eclipse is tool-centric not programmer-centric.

Eclipse requires you to scavenge around for modules/plugins to build a complete suite. Until the recent availability of Callisto web site, you'd never know if you had the complete suite to build J2EE projects.

Eclipse does not spontaneously create a build file for you. You have to learn ant scripting to create your own build file. If you wish to be a Java programmer but not an ant build writer, Eclipse is not for you.

Eclipse docs says, eclipse variables will be available to any external tools. Ant builder is an external, tool right? Try running an ant script with any Eclipse variables (e.g. ${workspace_loc:/source} or ${workspace_loc}/source ) - response is 'C:/myworkspace/${workspace_ not found'. You have to duplicate by hand all the Eclipse variables into the External Tool window - which defeats the purpose of variables.

Eclipse does not allow you to define source and webroot folders that sit outside your j2ee or dynamic web folder. But you can achieve that but editing the resourcelinking tag in .project file. You can also achieve that by writing your ant file to look somewhere else but if you do so what you see on explorer is not what you get.

Don't delete your web folder on your j2ee or JSP project in Eclipse. Right click on project properties , there is no way to re-specify your new webroot folder. You'll have to recreate your folder.

Why is Borland, Google, etc moving towards Eclipse? Because Netbeans is a complete product while Eclipse is not. But drawing people towards Eclipse, these commercial enterprises is able to sell a product, while in Netbeans they wouldn't be able to! Of course, the actual reason should be - because Eclipse is tool-centric and low-level, that allows Borland and google to transform it into the programmer-centricity they wish to have. But I don't see why they cannot do that with Netbeans platform. Hmmm... Must be some java politics going on.

The netbeans official site recommends 1G for netbeans. The minimum memory should be 512M. Upgrade your hardware if you feel sluggish or unstable. The minimum memory for Eclipse is 1G. I think every fullfleged java IDE requires 1G memory, or at least 512M as the minimum requirement.