Two links, one from dzone and one from sys-con, addressed "what's wrong with java". Interesting thoughts, the dzone guy has an excellent point. But there's more.

The first article is "Java kicks Ruby on Rails in the butt." It's on a sys-con site, so have Adblock up and running unless you want to go blind.

The second is on Dzone: "Java Kicks Rails Butt? Are Java developers everything that's wrong about Java?"

There's a lot going on here. The first article is basically pushing model driven architecture. He walks through a simple RoR app, then shows how OpenXava would do the same app. That's all fine and good, but he has this paragraph stuck right before diving into code:

The productivity in Java world is a cultural problem, not a technical one. That is this is not a Java fault, it's our fault, we, the Java developers, need to design very beautiful architectures, to apply everywhere the GoF patterns, to do everything reusable, to put 3 tiers in all our systems and to use web services for all. We are not looking for simplicity, therefore we have not found it. But, Java is a very elegant language that allows simpler approach to software development.

Whoa! In other words, we java programmers (and hes including himself) are overengineering. We're not being pragmatic as a culture, which may explain why the pragmatic programmers have so little java. Keep this point in mind.

The second link is a response to this one, focusing on that quotes paragraph. He says this:

The author of the article missed an important trying to separate the language itself from the culture of its community, which is a huge part of any platform and it should be considered when analyzing or comparing different platforms. Is that the "social" aspect of a programming language or platform? I guess so (although I feel a total cliche saying it).

Interesting! So when we as programmers arent pragmatic or bright or whatever, we bring down the language, especially for kids looking for the next cool thing. I like the social responsibility thing, but the result is kinda scary, and yes, Forrester, I'm looking at you.

But here's the thing: one of the other points the response had was this:

The author claims Java developers are what's wrong about Java. In his view Java is a elegant language and since the developers never looked for productivity hence it was never found.

That's an oversimplification obviously but he does have a point. Who doesn't remember the first versions of EJB? Java developers have a tendency to over-engineer applications, I remember 10 years ago I was doing a small Astrology site for someone using JBoss 2 and EJB. I had DTOs, I had remote calls, I had Sessions Beans for business logic, I had Entity Beans (CMP, BMP) for the data access layer, and of course interfaces for everything. What a waste! I am glad I learned my lesson.

This made me mad. Look: people blame EJB 1 for being a pile of dog turds. That's fine, but most people do so when they should have been looking in thr mirror.

Here's the thing:

EJB was meant for remote calls. Always. It included transactions. It was meant for CORBA.

People looked and said "wow, how neat, I can run stuff wherever" and applied it everywhere. That's because these people were not smart, and because the people who pushed EJB 1 never stoppped to say "by the way, only use this if you need its features, because it's going to crush your performance and be a pain to develop with otherwise."

Should they have said that? Yes, they should have. Along the way they could have dumped the ejb compiler thing from 1.0 (and they did.) But the biggest problem is that they never addressed the cultural impact, by saying "99% of you don't need this, so don't use it until you do."

Look at what happened: EJB 1 was a giant "screw you" to developers. They bought into this magical tool that wasn't meant for their use, and got slaughtered in production because they used it when they shouldn't have, on containers that sucked, and yes, WebLogic, now i'm looking at YOU.

So then what? People like Rod Johnson came along, writing books on using J2EE without EJB. It's a good book, and worth reading, but Rod leveraged it. His message was 'don't use EJB unless you really need it," which is what the EJB people should have been saying, except he didn't emphasize the "unless you really need it" part, and along the way, created the Spring Framework, which people saw (slightly unfairly) as a competitor to EJB.

Good for him, i guess, he profited from peoples' ignorance, but I really wish they'd have been more upfront about where Spring fit. I know, I'm being a little unfair here, because I don't think they ever really came out and said "no, you should never use EJB, buy our stuff instead," and God knows Spring's useful. I don't code without it any more.

But I've always thought about that cultural divide, the one the articles are referring to, and this guy pointed it out.

Hmm. I think Java has a has been put into good usage for some time and perhaps in the several coming years. Though it is possible that java could phase out in the market 5 years from now due to computer language advancement and sophistication of gadgets and technology.
<a href="www.loanrater.co.uk">loan</a>

I mostly agree but like to ass that this cultural divide seems to be a problem of the enterprise IT as a whole. Just look at the widely applied systems there (of course mostly in the Java eco system).
Bloated things like Tibco, Weblogic, you name it... are implemented even for the simplest task.
The sentiment seems to be "We are enterprise, we have to use big stuff!"
In our recent project within the financial industrie we replaced a huge weblogic portal with a lean Servlet based solution.
Spring does the wiring and adds some convenience to deal with aspects and JDBC et al.
We still use Java but switched to Groovy whereever possible. IMHO Groovy and Scala, too might lead the way out of that cultural confinement as they open up the JVM for a new spirit that has been inspired by things like RoR and such.

ass should mean add, of course...

Even Spring has a cultural influence in the Java developers that forces us to do too complicated software. The reasoning is: I'm a good Java developer so I use Spring, so I have to use interfaces, implementation classes, factories, xml definitions, dependency injection everywhere, and sometimes is just simpler creating a simple class, and instatiate it using 'new'. Spring induces the overuse of Strategy pattern.

Sorry, but I think this is spot on. Java is a pretty elegant and concise langauge but I have never seen so much over-engineering as I have in the Java industry. Most developers have frameworks coming out of their ears and generally have no good reason to be using them. They are so bogged down in XML and beans that they are producing completely incomprehensible and incredibly complicated code for even the most simple problems. Even Spring and Guice are not a solution, but part of the problem. Java developers these days seem to think that they shouldn't have to write any code and that there should always be some magical framework that can do it for them. Unfortunately this just isn't true. We need to get back to basics and learn to write clean, simple and efficient code.

Yeah, I agree. Java as both a language and a platform is fine, but way too many Java-based solutions are overengineered and unnecessarily complex. And its many frameworks... ugh! Also, it must be said, it doesn't help that Java is a verbose language. But it's mostly our culture and not the language itself.

Denying that we have a problem isn't going to solve it.

Sorry, but I think this is spot on. Java is a pretty elegant and concise langauge but I have never seen so much over-engineering as I have in the Java industry. Most developers have frameworks coming out of their ears and generally have no good reason to be using them.

A big-up to this.  The biggest misconception that I see about Java is that people think that if you are a 'real' Java developer, you should not be creating your own types.  These things are to be done by 'someone else'.  Additionally it's common to believe that you should not create your own high-level abstraction (roughly: frameworks).

The problem with these beliefs is that the only mechanism that Java has to support the good, clean code is the definition of types and abstraction layers.  If you aren't using these, Java degenerates into a procedural language and not a very good one.

Frameworks like Spring, Hibernate, etc. are intrusive.  They require you bend your designs to meet their needs.  Additionally, we've become overwhelmed with a semi-functional class of programmers that doesn't actually understand what these frameworks are doing and how they work.  That's OK when things are going well but when the inevitable problems arise, they are baffled.

Ultimately, the problems all arise from a lack of goal-based design.  Instead of defining the goal (e.g. problems to solve), coming up with a solution, and then picking the best tools and approaches, we too often start with tools and frameworks, pick a design and then try to make the the goal fit those choices.

I think many people is critizing the Java stack because for many different projects it just works (if not, they wouldn't even care). MDD is ok for small sites, or prototypes, but I think anyone would have a real hard time trying to fit a high customizable enterprise app into it.

It's just a matter of choosing the right tools for the right job, and of course Java won't ever be it, but in the large scale app domain, it will be most of the times. And there, I agree that as Java developers we need to make an extra effort to understand the tools we use, and the ones at our reach.

There's a ton of Java code that is appropiately architected and elegantly written. Yes certain things were overused (like EJBs) but that happens with any tool.

Am I saying something stupid if I think that PHP is nothing more than JSP? Only less organized (a bunch of old system librariies) and without the enormous diversity of Java behind it. So why in the world is PHP so popular and JSP not? Probably just because of the cheap hosting.

Am I saying something stupid if I think that PHP is nothing more than JSP? Only less organized (a bunch of old system librariies) and without the enormous diversity of Java behind it. So why in the world is PHP so popular and JSP not? Probably just because of the cheap hosting.

I'm not a PHP fan or anything but the difference I see is that PHP is a (for most web sites) a whole solution in itself where JSP is a single piece of a complicated interaction with other programming tools.

PHP is fine for a basic website but in my recent experience with a trading partner, completely inadequate for anything more technically difficult such as integrating with a secured web-service.  That requires C/C++ and most PHP developers didn't sign up for that.  Of course, I know almost nothing about PHP so I could be all wet with this.