> It's unclear what the big missing feature is after lambdas.

- Value types, GPGPU, replacing JNI with an improved JNR, reified generics, making Unsafe an official package, modularity, AOT compilation, replacing Hotspot by Graal...

Some things discussed here,

http://www.oracle.com/technetwork/java/javase/community/jlss...

http://openjdk.java.net/projects/panama/

http://openjdk.java.net/projects/sumatra/

http://openjdk.java.net/projects/valhalla/

https://wiki.openjdk.java.net/display/Graal/Publications+and...

Yes, there are many more features to come, but they don't look like they will be as important as lambdas (and default methods) for everyday coding.

Thanks for the links.

I think you underestimate you important some of those are.

Specially for people doing big data analysis in JVM languages or jumping out of Java to languages like C and C++ for the last performance increase.

The Java community is so large that these are important communities in themselves. But they're still subsets. Someone writing a portable Java library isn't going to want to call into native code or rely on specific hardware. Changing the language itself affects everyone.

If you bothered to follow the links, they imply language changes.

I did, actually. Value types are nice but annotation processing can do pretty well:

https://github.com/google/auto/tree/master/value

I'm honestly not seeing as big as lambdas (or generics in Java 5). If you think they really are that big, perhaps you could explain why?

> It's unclear what the big missing feature is after lambdas.

I agree. I think Java pretty much is what it is by now. As someone said, "For those who like this kind of thing, this is the kind of thing they like."

Java-the-language is pretty complete. (Even though Haskell people complain about the lack of a decent type system, and Lisp users complain about the verbose syntax, and C++ folks wish they had destructors.) Java-the-platform is in fine shape (the library is Java's unsung best selling point.)

Java-the-enterprise-bloatware-behemoth... well, it really needs to be shot in the head and the body incinerated, but it may actually do the jobs it's given to do about as well as anything that might replace it.

In terms of language features, lack of properties are the thing that is keeping me from using java. I would love to be able to have public variables, with the understanding that I could just convert them to properties later on if I need to. Instead, java conventions suggest that I always make a getter and setter for every single variable that I want to expose.

Some Java conventions are unfortunate. Setters aren't a great idea, actually. The Guava team recently open-sourced AutoValue as a more modern approach:

https://github.com/google/auto/tree/master/value

Fixing this stupid issue seems like such an obvious thing to do I can't imagine why it wasn't addressed ages ago. Having property notation would immediately get rid of 30% of the code in the codebase I currently work with, and that seems incredibly valuable.