Link Details

While your article has some truth to it, I don't think your point of view (and that includes the first article) and arguments are consistent. You describe how the desire for backward compatibility is dragging Sun and Java down and describe this inflexibility as disadvantage, yet you don't actually desire any change.

You have described annotations as useless, generics and closures as overly complex. If you don't want change, why do you care about the downsides if backward compatibility? If you describe Python breaking compatibility several times as advantage, I flatly don't understand how adding features that you don't have to use while remaining backward compatible can be seen as negative.

Your article puts you in a logical state of sin.

I've posted a reply on my blog to some comments there that covers some of this, but I'll address this here as well...

I'm worried about changes to Java making things worse than they were beforehand. Adding complexity isn't a good thing when the language was meant to be simpler than it's predecessors (C++ in particular). I'm not against changes to the language so long as they don't end up making things more difficult for developers in the end. One of the reasons we end up with more complexity in the language is the insistence for backward compatibility which forces compromises to otherwise good language changes.

Also, whether I actually choose to use a new feature of the language isn't as important as whether others decide to...as I'll likely end up having to deal with the feature whether I want to or not. Someone has to go back and maintain code that uses those new features at some point. A concern I have along these lines (and I've seen proof of this firsthand with Generics) is that some of these features will get misused when far simpler solutions would have worked just fine. I admit this isn't a good reason excluding new features, but it's something that I think should still be thought about given the popularity of Java and the size of the community. A large number of code bases are going to make use of whatever features are available in the language...regardless of whether they are the right choice or not.

I hope that clears things up a bit. I still have some other points I want to address in future posts that might make my point of view little clearer, too.

Nevertheless, thanks for input :-)