Java is primarily useful for huge things. Since it makes so many things explicit, you can orient yourself very quickly in a project. If you see a symbol, you don’t need to pull out a special tool (like cscope for C) to tell where it was defined—the code tells you. Yes, it is possible to write spaghetti Java, but it’s easy not to.
Also, if you have something that will be on for a long time and need it to eventually act with compiled speed (e.g. a webapp), java with the JIT is soon as fast as an always-compiled language.
The inability to pass functions as arguments without creating a class for them is one of the annoying parts. Maybe some syntactic sugar will be (or recently has been?) added.
The inability to pass functions as arguments without creating a class for them is one of the annoying parts. Maybe some syntactic sugar will be (or recently has been?) added.
Java 8 (currently scheduled for March 2014) is adding proper lambdas.
There are other JVM-based languages that do have more easily accessible functions, but most of them come at a performance cost—the JVM really isn’t very flexible.
To the best of my knowledge, no-one has tried to design a language that gets the best possible performance from the JVM while still throwing away C-style syntax and unnecessary limitations.
What I’m talking about here would still compile to Java bytecode. It would just be some syntactic sugar to easily wrap static functions in anonymous classes.
The only thing that really bugs me is the inability to use variables declared in a try block in an ensuing catch or finally block. That would let you scope things much better.
You can do polymorphism with generic types, and that’s been around for a while.
Like,
List listOfThings = new ArrayList();
listOfThings.add(new Thing());
Thing t = listOfThings.get(0);
Is this not what you’re talking about? Generics need no runtime support, but they do enable a lot of compile-time checks.
Generics certainly don’t do parametric polymorphism or algebraic data types. Of course anyone can write a Pair or Triple class with trivial get and set methods, but that looks (and acts) silly.
Ooh, another thing I’d love is to have there be a Bracketable interface that lets you use brackets to call the class’s get and set methods. Then you could access Lists and even Maps with array syntax. It’d be sweet.
Java is primarily useful for huge things. Since it makes so many things explicit, you can orient yourself very quickly in a project. If you see a symbol, you don’t need to pull out a special tool (like cscope for C) to tell where it was defined—the code tells you. Yes, it is possible to write spaghetti Java, but it’s easy not to.
Also, if you have something that will be on for a long time and need it to eventually act with compiled speed (e.g. a webapp), java with the JIT is soon as fast as an always-compiled language.
The inability to pass functions as arguments without creating a class for them is one of the annoying parts. Maybe some syntactic sugar will be (or recently has been?) added.
Java 8 (currently scheduled for March 2014) is adding proper lambdas.
There are other JVM-based languages that do have more easily accessible functions, but most of them come at a performance cost—the JVM really isn’t very flexible.
To the best of my knowledge, no-one has tried to design a language that gets the best possible performance from the JVM while still throwing away C-style syntax and unnecessary limitations.
What I’m talking about here would still compile to Java bytecode. It would just be some syntactic sugar to easily wrap static functions in anonymous classes.
Sure, that’s what I was talking about.
Though Java syntax really isn’t that great, and if you’re changing it at all, there’s a lot more low-hanging fruit than just functions.
The only thing that really bugs me is the inability to use variables declared in a try block in an ensuing catch or finally block. That would let you scope things much better.
What are you thinking of?
Lack of multi-parameter polymorphism, lack of return-type polymorphism, lack of algebraic data types, lack of parametric polymorphism, etc.
Okay, essentially I want Java to be Haskell. That’s an impossibility, but most of the type-level stuff needs no runtime support whatsoever.
You can do polymorphism with generic types, and that’s been around for a while.
Like,
List listOfThings = new ArrayList(); listOfThings.add(new Thing()); Thing t = listOfThings.get(0);
Is this not what you’re talking about? Generics need no runtime support, but they do enable a lot of compile-time checks.
Generics certainly don’t do parametric polymorphism or algebraic data types. Of course anyone can write a Pair or Triple class with trivial get and set methods, but that looks (and acts) silly.
Ooh, another thing I’d love is to have there be a Bracketable interface that lets you use brackets to call the class’s get and set methods. Then you could access Lists and even Maps with array syntax. It’d be sweet.
All three of the things I asked for in this chain now exist as part of Java -
-- Lambdas—code snippets you can pass (without even declaring them as functions, even!),
-- brackets for accessing Lists and Maps, and
-- a way to declare variables for both a try and its associated catch and finally blocks.
I’m kinda floored.