I agree with respect to annotations. This is another reason I’m writing yet another MVC. Struts2 and XWork annotations are now just as bad as the XML configuration, especially for validation! JCatapult’s MVC is pretty lightweight with annotations and more importantly they aren’t generalized annotations like many other frameworks use. For example, Struts2 uses a single annotation for all Results including forwards, redirects, streams, xml, etc. JCatapult uses mutliple annotations such as Forward, Redirect, Xml, Stream, etc. Each annotation contains the parameters that make sense for that result type.

@Van der Shart

Yeah, everyone wants this. There is some good work going on at Sun for JDK 7 that will make generics much better in this respect. I forget the exact person working on it, but hey has some great ideas to “fix” erasure.

@Mathias

I’ll definitely check out nextgen. Sounds very cool. The biggest issue will still be the single instance of a Class per Classloader regardless of the type parameters used. AFAIK the majority of the issues aren’t in the compiler, but in the JVM.

@Blake

I ran into the exact same situation and since XWork and Struts are coupled to OGNL completely and I’m not an XWork or OGNL committer, I couldn’t do anything about it all really. Plus, OGNL is overly complex because it is an entire expression language. I didn’t need an entire EL to start, just something for setting parameters into the actions So, I wrote my own solution. The nice thing about this solution is that it doesn’t use any lexer/parser and correctly handles generics, even some of the more tricky cases. If you want to take a look, check out the code from the Google code project. It is at http://jcatapult.googlecode.com/svn/jcatapult-mvc/trunk in a package named org.jcatapult.mvc.pamareter.el

And while we are talking about generics without type erasure, perhaps you will allow me to mention NextGen, a javac compiler replacement developed at Rice University that allows first-class generics: http://japan.cs.rice.edu/nextgen/

Abuse of annotations is fairly rampant IMO. Use them conscientiously.

@Integer
var age

What’s the difference between that and just defining the type? Nothing as far as I can tell.

I just don’t see the bad in generics. I guess I haven’t been convinced that 99.9% of everyday generic usage is bad. I understand that some generics can be a little bit hairy, but that complexity is usually left to the platform and framework developers who can grok it.

The only way I could see it improving would be to make the syntax simpler and to hide complexity. The issue seemingly always comes back to type determination by tools. Can a tool determine the types in a collection? If you have a String[], can you convert it to a List<integer>