Heh, if a java developer is worth his salt he will eventually be using idea. It's heads and shoulders above every other Java IDE out there.

The Java developers I've known who are worth their salt, don't use IDE's :/

If they're not using an IDE, then they've not yet worked on large projects. Either that or they're doing themselves a serious disservice. This from a hardcore Emacs-and-shell guy until fairly recently...

Maybe they're large projects because people are using IDE's ;) clicking once to insert getter/setter/hashcode/tostring/etc instead of writing what is necessary.

idk depends how large you're talking.

So you write your hashCode/equals/toString methods, and your getters and setters all manually instead of clicking three times? Automatic generation of delegate methods is also a godsend.

What about refactoring? Eclipse's rename tool for one changes the way you write code as refactoring is so trivial you do it without thinking.

Eclipse's debugger is also top notch, far better than jdb.

* Never use a debugger, it's usually pointless. * I hardly ever use getters and setters, and write by hand if needed. * hashCode/equals/toString by hand when they're needed.

I also hate the thought of an IDE refactoring my code. I've seen it before, and I've seen it break stuff.

It's just typing :/

Authors of novels could use auto-complete. They could tab complete characters names. I expect they could use built in sentence constructs, or even re-factor parts of the novel. But they don't.

Well when you're working with other people's code debuggers are most definitely not pointless.

I'm not sure how you can write any non-trivial Java program without lots of getters, unless you expose your fields everywhere, and end up in maintenance hell.

hashCode/equals/toString are boilerplate code that is best machine generated, because humans make mistakes when writing the same boilerplate code for the 500th time.

The fact that Java is strictly statically typed means the IDE can safely refactor your code without breaking things, though obviously you can still get naming conflicts, which if occur the IDE will not let you continue.

Your comparison with natural language is disingenuous, they are not parsable by machines, and hence are not easily refactorable; a word processor can't determine the context from your cursor location, and hence can't auto-complete words.

Here is Java's complete grammar: http://java.sun.com/docs/books/jls/second_edition/html/synta....

I also haven't seen a character name like SimpleRemoteStatelessSessionProxyFactoryBean (that's a real Spring class name...)

Depends what you consider trivial.

I don't touch any of the Bean / Spring / 'enterprise' madness. Perhaps that's the difference.

Exposing fields everywhere isn't really a maintenance hell, it's simple enough to find everywhere that accesses the field, I'm not sure why adding getters/setters is so much better :/ Sometimes it makes sense when the get/set does more than just modify a field.

Things like SimpleRemoteStatelessSessionProxyFactoryBean are clearly madness, and give Java a bad name. Also reinforce the silly opinion that to write Java you must use an IDE.

I agree. I know some awesome Java developers that use Netbeans, Vim, Emacs, Eclipse, and one or two that use IDEA. And this is not on tiny projects or lone coder things. This is an enterprise Java app that is probably one of the largest Java apps in the world.

IDEA might be great, but so is Eclipse, NB, Vim, and Emacs in the hands of a developer worth their salt.

Really? What do they use then?

A text editor and shell.

Sounds like a recipe for RSI.

I've been writing assembly/java/etc by hand for 20 years, no problems yet. The bottleneck has never been 'speed of typing'.