I am really growing tired of hearing the same old "Java has Eclipse or IDEA or Some-other-IDE, therefore you can be as productive in Java as in any other language" phrase spouted whenever anyone mentions Python, Perl or Ruby (or Lisp or Smalltalk). Sure, Eclipse is neat. Sure, even I use Eclipse at work.

Eclipse makes it easy to find appropriate Java methods, because it has a powerful auto-completion. It even opens up the corresponding documentation in the context. And yes, Python IDEs do something similar too, but they can never be quite as complete as Java's, because of the dynamic typing. Ditto for refactoring. Ditto for many other features.

But it does not mean that programming in Java suddenly, magically becomes easy. Programming isn't hard because you can't always find the right libraries, classes and methods instantly. (Programming might be a bit inconvenient because of this.) Programming is hard, because it's complex. Programming is hard, because it's abstract. Programming is hard, because you can't visualize it. Etc.

Programming isn't hard at the level of individual expressions and statements. Programming is hard at higher levels, at higher levels of abstraction. But these two are not separable. The higher levels, where things are more hairy, are composed of the individual expressions and statements. What's more, you can't escape from the lower levels. You drag them with you whatever you do. This is why programming in assembler is harder: you have drag the most low-level statements with your abstractions. The devil really is in the details.

The issue is of course not as bleak as I have painted it. You can make your own abstractions, making it easier for you to work with the high level concepts. Making abstractions is indeed a very powerful tool. Unfortunately, abstractions are not silver bullets either. (Not in the form of Objects, or in the form of Subroutines.) You still can't completely escape the individual expressions. You just can't. Abstractions leak. Bugs creep in. Integration becomes harder the more components you have. In some sense, abstractions makes the thing just harder.

What dynamic languages target is the level of the individual statements. They make —it is argued— the lowest level visible to the programmer a bit higher. They make the base level a bit higher. It's the fundamental bottom-up programming. Make the language of the programmer a bit closer to the domain of problems. (Domain specific languages are even more powerful with this, but they have their own set of problems, too.)

The point is not to make programming more convenient (although that's arguably one side-effect of dynamic languages); the point is to make the difficult task of making large programs less daunting. It's of course debatable whether dynamic languages succeed in this mission, but IDEs do not belong to that discussion. It all boils down to this: No IDE is going to make Java a higher level programming language. Unless, of course, the "IDE" is actually a interpreter to some higher level language itself.