6 ms·

I think the best option for the community is to stick to JDK 1.6 and never upgrade. If people get sick of the Java language going nowhere they can just use Sca

I think the best option for the community is to stick to JDK 1.6 and never upgrade. If people get sick of the Java language going nowhere they can just use Scala on JDK 1.6, or some sort of fork of the Java language that compiles to bytecode that runs on 1.6, etc. I really can't see any of the open source projects embracing the commercial feature set. 1.6 is a really great platform. I don't see it being obsoleted, at least on the server side, for at least 5 more years and no doubt code will live on in production that runs on 1.6 practically forever.

8ren 16y ago
That makes sense, but people really like to see a future before investing (money or sweat).
melling 16y ago
This is really bad idea. Java and the JVM can still be greatly improved. Closures, fixing generics, tail call optimization, module system, faster startup, etc. JavaFX will be a nice improvement once it's integrated with Java.
- sukuriant 16y ago
  Hitting a couple of your points: What about Generics is broken? For the extent of power they seem to intend to provide (forcing methods to only take a particular type, and providing syntactic sugar so you don't have to cast everywhere. Tail-call optimization is just that, an optimization. A 1.6 compliant, open-source JVM could provide that. Same with the faster startup time. As I don't generally use closures, and would replicate their abilities through interfaces and anonymous classes, I don't have a comment on them; and you'd need to expound upon "module system" for me to say anything.
  - steveklabnik 16y ago
    > What about Generics is broken? I'm going to be slightly handwavy, so forgive me: Generics are implemented by doing type erasure[1] rather than as 'real generics' through some other method. This causes issues with runtime reflection. > would replicate their abilities through interfaces and anonymous classes, This embodies exactly what I hate about Java: In other languages, where I simply 'do/end' or ' \ ->', I have to create a whole giant pile of boilerplate bullshit to pull off something that's supposed to be easy. 1: http://en.wikipedia.org/wiki/Generics_in_Java#Type_erasure http://en.wikipedia.org/wiki/Generics_in_Java#Type_erasure
    - sukuriant 16y ago
      On Generics: I did not know they performed that slight-of-hand, internally. That does make them rather weak. On Java-bloat: to be fair, it's really not that much, especially if it's already a known interface: new TreeSet<Foo>(new Comparator<Foo>() { public void compare(Foo a, Foo b) { mycode(); } }); However, your point stands. I've just come to accept that as being a part of Java, myself.
  - crux_ 16y ago
    What's wrong with java generics: erasure. "Cast everywhere" is still happening. And useful info is hidden: eg there is no access to generic type info via reflection. Another wrong thing: generics are incompatible with subtyping. (No co/contra-variance, to use the pointy headed terms) Tail call optimization is not a mere optimization. A jvm cannot provide it and still provide conforming exception stack traces, for example. As far as closures: you're missing out :)
    - dantheman 16y ago
      Also tail call optimization changes the semantics of the language - it allows you to write code that would normally be incorrect
      - crux_ 16y ago
        True, although you have to be careful about "incorrect": the code will still compile (unless there's some corner case I'm missing?), so for that particular definition of correctness it is just fine without TCO. It just won't run (for very long). :)
        dantheman 16y ago
        I agree, but compilation is a low barrier for correctness :)
    - sukuriant 16y ago
      Would it be that impossible to keep a counter of what iteration of function X the user is on? Or, does tail recursion also count things like: int A() { return 1 + B(); } int B() { return 1 + A(); } (with necessary ending conditions)
      - crux_ 16y ago
        Yes, tail call optimizations include mutually recursive functions. Note that your example was not of tail calls, however. (Tail call would be: return A(...); that is, a tail call is one whose result is immediately returned.)
  - quicksilver03 16y ago
    The only thing that I would fix in Java Generics is the syntax, the use of angle brackets is what makes me reject the whole implementation.
- narrator 16y ago
  Yeah but unless Google buys Oracle or wins the Dalvik lawsuit and implements a better server side JVM than Oracle, I just don't see how it can happen. Closures work fine in Scala, BTW.
  - fauigerzigerk 16y ago
    Google cannot buy Oracle but maybe they can buy Java. But even the latter possiblity has become much less likely with the premium JVM announcement. Apparently Oracle is determined to monetize Java.

8ren 16y ago

That makes sense, but people really like to see a future before investing (money or sweat).

melling 16y ago

This is really bad idea. Java and the JVM can still be greatly improved. Closures, fixing generics, tail call optimization, module system, faster startup, etc. JavaFX will be a nice improvement once it's integrated with Java.

sukuriant 16y ago
Hitting a couple of your points: What about Generics is broken? For the extent of power they seem to intend to provide (forcing methods to only take a particular type, and providing syntactic sugar so you don't have to cast everywhere. Tail-call optimization is just that, an optimization. A 1.6 compliant, open-source JVM could provide that. Same with the faster startup time. As I don't generally use closures, and would replicate their abilities through interfaces and anonymous classes, I don't have a comment on them; and you'd need to expound upon "module system" for me to say anything.
- steveklabnik 16y ago
  > What about Generics is broken? I'm going to be slightly handwavy, so forgive me: Generics are implemented by doing type erasure[1] rather than as 'real generics' through some other method. This causes issues with runtime reflection. > would replicate their abilities through interfaces and anonymous classes, This embodies exactly what I hate about Java: In other languages, where I simply 'do/end' or ' \ ->', I have to create a whole giant pile of boilerplate bullshit to pull off something that's supposed to be easy. 1: http://en.wikipedia.org/wiki/Generics_in_Java#Type_erasure http://en.wikipedia.org/wiki/Generics_in_Java#Type_erasure
  - sukuriant 16y ago
    On Generics: I did not know they performed that slight-of-hand, internally. That does make them rather weak. On Java-bloat: to be fair, it's really not that much, especially if it's already a known interface: new TreeSet<Foo>(new Comparator<Foo>() { public void compare(Foo a, Foo b) { mycode(); } }); However, your point stands. I've just come to accept that as being a part of Java, myself.
- crux_ 16y ago
  What's wrong with java generics: erasure. "Cast everywhere" is still happening. And useful info is hidden: eg there is no access to generic type info via reflection. Another wrong thing: generics are incompatible with subtyping. (No co/contra-variance, to use the pointy headed terms) Tail call optimization is not a mere optimization. A jvm cannot provide it and still provide conforming exception stack traces, for example. As far as closures: you're missing out :)
  - dantheman 16y ago
    Also tail call optimization changes the semantics of the language - it allows you to write code that would normally be incorrect
    - crux_ 16y ago
      True, although you have to be careful about "incorrect": the code will still compile (unless there's some corner case I'm missing?), so for that particular definition of correctness it is just fine without TCO. It just won't run (for very long). :)
      - dantheman 16y ago
        I agree, but compilation is a low barrier for correctness :)
  - sukuriant 16y ago
    Would it be that impossible to keep a counter of what iteration of function X the user is on? Or, does tail recursion also count things like: int A() { return 1 + B(); } int B() { return 1 + A(); } (with necessary ending conditions)
    - crux_ 16y ago
      Yes, tail call optimizations include mutually recursive functions. Note that your example was not of tail calls, however. (Tail call would be: return A(...); that is, a tail call is one whose result is immediately returned.)
- quicksilver03 16y ago
  The only thing that I would fix in Java Generics is the syntax, the use of angle brackets is what makes me reject the whole implementation.
narrator 16y ago
Yeah but unless Google buys Oracle or wins the Dalvik lawsuit and implements a better server side JVM than Oracle, I just don't see how it can happen. Closures work fine in Scala, BTW.
- fauigerzigerk 16y ago
  Google cannot buy Oracle but maybe they can buy Java. But even the latter possiblity has become much less likely with the premium JVM announcement. Apparently Oracle is determined to monetize Java.