Buyer's remorse for Generics and Autoboxing?

We knew Generics were coming. There was an implementation of it that could be used with Java 1.4, during the long wait for the J2SE 5 betas and ultimately its final version. So, really, just now people are starting to say that it was a bad idea?

What happened? Did the silent majority get this one wrong? I remember five years ago when it was the most popular item on the bug parade, I didn't really think much of it. I thought that if there really is a critical problem in getting untyped objects from Collections, that to be completely honest, I was far more likely to just do an instanceof on stuff I pulled from the Collection, or to just catch the ClassCastException and live with it, rather than learning a completely new syntax to avoid the problem. 99 times out of 100, my code was the only one populating the Collection, so the chances of getting an unexpected type of object out of the Collection was zero.

So I voted all my bug votes for Java Media Framework stuff that never got looked at. That and the un-deprecation of ServletRequest.getParameter()... bonus points for anyone who sees how that relates to generics, but I digress.

Anyways, maybe there were people with principled objections to Generics, but it seems more people just shrugged and said "yeah, whatever" and plugged away with our work. Generics arrived and suddenly everyone realizes that they're probably more trouble than they're worth. Bruce Tate, in Beyond Java, even sees them as typical of what he believes are Java pathologies:

Java 5 is strongly touted as perhaps the most innovative major release of Java in half a decade. I do agree that it's going to have a significant impact. I'm not at all convinced that all of the impact will be positive. I regularly attend a conference called NoFluffJustStuff. The experts at the conference sit on a panel and answer questions. One of my favorite questions deals with new features in the language. The whole panel agrees that generics, as implemented, are a bad idea. That usually shocks the audience.

If you think about it, the Java generics Java Specification Request (JSR) introduces a whole lot of syntax to solve a marginal problem with no corresponding change to the Java virtual machine (JVM). I'm guessing that the typical Java developer rarely gets a class cast exception. And there are plenty of opportunities. Most of the objects in a typical Java application are usually in collections anyway. Whenever you take them out of the collection, you've got to cast them from Object anyway. At that point, type safety gives you about as much protection as a lap belt in a burning, plummeting 747. Yet, the generics syntax is invasive, and the implementation is worse. In an age when more and more experts assert that dynamic typing leads to simpler applications and productive programmers, Java developers are learning how to build stronger enforcement for static types.

I'm bringing this up because it's come up in multiple discussions in the forums. The thread Comparison operators by value kicks off with ideas about how to resolve some problems with = and == introduced by autoboxing. The thread moves on to consider whether Autoboxing as a whole is a mistake, and then brings in Generics as a fellow poster child for well-meaning features gone wrong. User kcpeppe writes:

No matter the conservative approach (which is the correct one for production) is to not change unless there is a compelling reason and the change will do no harm. I'm sorry but from where I stand, Generics do not meet that bar and autoboxing falls way below it. To be fair, I've seen cases where they can help but these are really use a few edge cases. I don't think the main core language should be designed by exception. n'uff said on this subject!

'nuff said? Do you think features like autoboxing and Generics are misguided? Has Java gone off the rails? Please join in the forum discussions and let us know what you think.