Maybe its better now. When I used to use JDeveloper is was very, very,
very slow.

-Robert

i would say it would depend on your needs, been devolpers will most
likly prefer sun's netbeans and maby the general devolper with eclipse
or intelliJ ?

Ditto... and while the learning curve here is even greater, the ability
to create plugins easily and within the environment is truly phenomenal.  
I just recently encountered the first situation where I wanted to do
something and it turned out to actually be easier to write and load a
plugin that used Eclipse's Java abstract syntax tree to perform the
modifications throughout the project, rather than doing it by hand.  I
probably saved two or three hours on the task.

Have you spent weeks getting plugins to work?  I haven't, and I've got
Eclispe set up to do J2ME, C/C++, Perl, Scheme, Tomcat integration, EMF
and GEF, Subversion, profiling (with TPTP), and UML.

Hi Robet,

  Could you please tell how did you run the jboss in eclipse???
I am using Jboss 4.0.2 and eclipse 3.1. Which plugin i need to install
for running Jboss using my eclipse

Thanks

Shouldn't that be Escape-Meta-Alt-Control-Shift?  Elsewhere Maybe All  
Commands are Simple.

Dan.

   I can't actually give hard numbers, but I can list a few features I
would have liked back in University.

   * Continuous compilation: At best, when you clicked "go", your IDE or
ANT task would recompile the whole project then and there, forcing you to
wait a bit. At worst, you were compiling manually from the command line (or
using ANT), and when your program behaved erratically, you asked yourself
"Did I remember to recompile?"

   * Source code navigation: You see a method call, and you'd really like
to peer inside it's code. In the old days, you essentially search through
the entire class hierarchy, 'cause you never know where a method might have
been defined, or when it might have gotten overloaded.

   * Error highlighting: In the old days, you'd try to compile and see some
error messages. You'd read the first one, and fix it, and then recompile.
Why? Because the other messages might have been spurrious errors caused by
the first one (especially if the first one was a syntax error). Now, errors
are underlined, and as soon as you fix one and save, the file is
automatically recompiled, and the new errors are shown.

   * Refactoring: This is a very general one. Refactoring used to be
tedious and error prone (especially if you didn't have error highlighting).
It was difficult to remember all the small changes you had to make. Now it's
two or three clicks, and it's done.

   There are many others, but these are the ones I'm sure most Eclipse
users use every day.

   Then there's stuff that's probably relatively specific to my company. We
exploit the fact that Eclipse is highly extensible a lot, and have some very
powerful plugins. I wrote the front end to a COBOL 85 compiler "manually" (I
used generators like JavaCC and JTB, but not our homebrewed Eclipse plugin,
'cause it wasn't developped enough yet), and it took me about 2 months to
finish. It was just a lot of tedious coding involving dealing with every
keyword in COBOL (of which there are a lot). The "difficult" part could be
isolated into a few small modules. Because I developped it over 2 months,
the style and API is inconsistent: over time, I found better ways to do
something, or found out that I needed some methods to be more general, etc.

   When our plugin was ready, I spent about a week writing code in our
proprietary language, clicked a button, and another COBOL 85 compiler front
end was generated, having all the same features of the original one, except
now the API and style was completely consistent (since it was all described
over the course of a few days instead of months).

   Now less than 3% of our Java code (measured by filesize) is written by
humans.

   We've got several compiler front-ends right now; for Java 1.4 (i.e. no
generics support yet), C, C# 1.0, COBOL 85, SQL, etc. and we will
occasionally want to make architectural changes to all of them. For example,
we were using the (vanilla) Visitor pattern to go through the ASTs and
perform computations on them. We decided to scrapped the visitors, and go
with a hybrid of the "Guide" pattern and the "Visitor Combinator" pattern.

   Normally this would be a monstrous task. We're essentially rewriting the
core components of every compiler for every language we support! But with
our plugin, it's just a matter of changing a handful of Java classes (20 at
the most), perhaps change our templating language a bit, click the "go"
button, and all the compilers will be regenerated using the new design
pattern.

   The Eclipse team describes Eclipse not only as an IDE, but as a
platform. We've taken that idea and ran with it. We don't just code using
Eclipse; we write tools custom-tailed and specifically designed to solve the
problems that WE are facing. In that sense, Eclipse is a meta-tool that
allows us to create the tools that bring us about a 8x savings in time, and
a 33x savings in codebase size (which reduces maintenance costs).

   - Oliver

Drifting into semantics, even "best" does
not necessarily imply "good".

   BugBear

That was a good page,  good poltical ammo for my republican
adversaries. ;)

But onto IDEs.  Your forth point is the key.  There are people that
learned the intricacies of their IDEs that they don't want to give that
up.

Yes this qualifies as not having to spend much time configuring up
front!

It was pleasent how my target names were recognized and build, clean,
documentation generation, and testing where all setup.

NetBeans installed without problems and imported a 250 file project
very quickly.  Very promising.

Another positive was that NetBeans didn't polluate project directories.
In total it created one xml file in the root directory.  I don't like
clutter; I'm compelled to understand every file within a  project.

I'm just beginning to explore NetBeans but like what I see.  Definately
a better experience than Eclipse installation/setup.

Thank you.

Opalinski
opalpa@gmail.com
http://www.geocities.com/opalpaweb/

In another data point for Chris' 4th -- already trained in one IDE or
super-smart editor and don't have the budget for learning another,
we again find someone pointing out a feature that exists in all
three of the major IDEs.

Ya might want to check with an Eclipse user next time.  There is
similar feature in Eclipse.

I continue to cheer all three IDEs just to keep the competition going,
that last thing we need is an IDE monopoly.

-Paul

One thing they could do to make import friendlier is tell you what the
target directory of thing you are importing will be and ask you to
confirm that, giving the example of the fully qualified name of the
first file that will be copied.  So many times I have imported then
had to go looking for where it put it, and move it to the proper
place.