I just saw Joe Darcy's JDK 7 in a Nutshell talk (9.5 minutes) from O'Reilly OSCON Java 2011. The new features he talked about were a bit of type inference so that you no longer have to repeat yourself in some of the most egregious ways the language formerly forced us to, and switching on String.

If this had happened 12 years ago, I would have felt like the language was on the right track, trying to make things easier and cleaner for the programmer. Instead, I feel like we got over a decade of being told why all the choices made in Java were the best way and that we should just accept and love them (and many did).

Only now, after years of dissatisfaction that led to more succinct and powerful languages on the JVM, do we finally start seeing some of these fundamental improvements. But it seems like they only happened under extreme duress after a lot of resistance. And perhaps these features might be helpful, but I can't see them stemming the flow away from Java towards other JVM languages for those that no longer want to struggle with the limitations of Java.

For example, in Scala the decision to use type inference is at the core of the language, not an afterthought. So defining an object is about as clean a process as you could hope for. Adding a little inferencing in Java 7 doesn't make a dent by comparison.

With Scala's pattern matching, you can switch on pretty much anything. Someone who is frustrated by the limitations of switching on integral values is not going to see enough of an improvement via string switching.

It's nice that Java is making these improvements. Java made some fundamental shifts in the programming world -- before Java everyone believed that virtual machines and garbage collectors would never be practical, for example. But it seems to me that the world started moving on awhile ago. The productivity and financial benefits of languages like Scala, Groovy, JRuby, Jython and numerous other JVM languages are getting harder and harder to resist.

val (minors, adults) = people partition (_.age < 18)

> val (minors, adults) = people partition (_.age < 18)
> 

val startingWithA = people filter (_.name.startsWith("A"))

val names = people map (_.name)

def isMinor(age: Int): Boolean = {
  // oh so complex majority rules
}
val (minors, adults) = people partition (p => isMinor(p.age))

public boolean isMinor(int age) {
  // oh so complex majority rules
}
List<Person> minors = new LinkedList<Person>();
List<Person> adults = new LinkedList<Person>();
for (p : people) {
  if (isMinor(p.age))
    minors.add(p);
  else
    adults.add(p);
}