Bill Burke jumped onto the computer after a painful last few minutes of the superbowl to tell us how he could be done with Java:
I also do not believe that Java is the end all, be all of existence.
He thinks that a new Java needs to come around and it must have the following features:
- Be typesafe, statically typed
- Have an IDE that supports the same features as modern Java IDEs
- Have a rich set apis and libraries to build my applications from
- Have a viable commercial ecosystem
- Have a vibrant open source community.
If Java is to stay around it “needs elegant, typesafe closures to complement annotations as a way to implement DSL. It needs a standard, non-code generating way of adding behavior to annotations. It needs a structural syntax to make initialization easier. AOP support might be nice too, or at least JVM support to make it easier to implement AOP-like features. Better zero-turnaround development features in both the JVM and APIs like Java EE, Seam, Hibernate, Spring, and JBoss AS would help out tremendously as well.”
BEEP BEEP BEEP
Ok, ok, what am I doing here?
After listening to the political commentary this “season” for what seems like an eternity, I decided to see how I could turn around something that someone said and make the opposite point.
Bill was actually ranting against dynamic languages and FOR Java. Just like certain benchmarks, it is easy to take things out of context and paint a different picture.
Bill, the result must have been hard to take, but you did have a fantastic season.
February 4th, 2008 at 10:05 am
Nice Dion! Thanks for the twisting of words, gave me a chuckle. BTW, I actually would be ready to throw out Java if it had all those features and tools packaged up as a statically type-safe language. What is the chance of forking Groovy to do this?
FYI, my blog was more of a rant against propaganda than a rant against dynamic languages. I enjoyed my time programming in Python, Perl, and Visual Basic.
February 4th, 2008 at 11:05 am
Interesting, if Bill’s thoughts are anything to go by it seems we are very much on the right track with Qi4j :-)
February 4th, 2008 at 2:53 pm
Rickard, if you mean Qi4j puts us further down the path of wanting to ditch Java, then, yes, I agree with you. I’m not trying to be factitious here. What your framework shows is that Java lacks serious dynamic features. Thank god you’re even more irrelevant than me in the Java community now and we won’t have to worry about Qi4j exposing Java’s gaping holes.
February 5th, 2008 at 12:43 am
Bill, if I had any idea what it is you are trying to say I would respond, but I simply cannot grasp it. I have, for example, no clue what you mean by Qi4j showing that “Java lacks serious dynamic features”. What dynamic features is it showing that Java lacks?
Nevertheless, it doesn’t matter, because as you say I am completely irrelevant so don’t worry…
February 5th, 2008 at 7:03 am
Bill and Dion,
For what it’s worth, Scala has most of what you want today. Especially the type safety with type inference (reducing line noise) and well-designed closure syntax.
February 5th, 2008 at 9:11 am
@Dave: yes, but Scala still allows you to do dynamic typing no? I want the constraint of having to do static typing. Then, instead of stripping down Groovy, how about we do that with Scala?
February 5th, 2008 at 12:59 pm
Groovy has all the features except statically typed _only_, it can be dynamic or static as you like. On the other, as Dave pointed out, Scala has some of those features (1 and 3 come to mind) but the other still require some time to grow/mature (it will happen eventually).
But my opinion would be to use Groovy and move on =-)
February 6th, 2008 at 12:02 am
Scala is fully statically typed.
February 6th, 2008 at 12:07 am
Bill,
No, Scala doesn’t have any dynamic typing. However, you appear to be confused as to what that is, because your post suggested a “static dynamic language” would be a good thing. Those are exact opposites. Let’s make it clear. A statically-typed language is one in which all variables’ types are decided statically; that is, they can be discerned from the code. A dynamically-typed language is one in which variables don’t have types (or you can say that they all have the same type, but the difference is a way of thinking rather than a technical difference). In this paragraph, a function or a method is just a kind of variable.
Whether a language is static or dynamic has no bearing on whether you have to explicitly give types to variables. Scala has type inference, so:
val x=”hello”
works, and x thereafter has the type String. That’s still a static type, there’s nothing dynamic going on here. You can specify the type if you like, e.g.:
val x: Object=”hello”
I wouldn’t say Scala supports most of what you want, because most of it is non-technical (large community, etc.). I can say that Scala is a well-designed language that you can either pick up and pretend it’s a better Java, or use to explore functional programming. It has a lot of syntax, but you’ll probably find that you don’t use a lot of it. About the community; there are 60 users in its IRC channel, and just enough mail in the mailing lists that I need to start filtering it somehow. The best thing about this community is its variety – you have pure functional people hanging around with OOP people and they can actually share code!
February 13th, 2008 at 1:31 pm
Long live Groovy!
February 13th, 2008 at 10:33 pm
who the hell is Bill Burke
February 13th, 2008 at 11:34 pm
“who the hell is Bill Burke” – good question!