It’s not without a certain sense of irony that just as Gilad Bracha, Sun’s
language expert, starts
blogging
about the next Java
, Microsoft publishes the specification for what will
become

C# 3.0
.  Interestingly, these two pieces of news are a pretty good
illustration of how the two companies work.

Gilad’s post discusses the possibility of adding a new bytecode to Java’s
virtual machine:  invokedynamic.  If you put aside the
obligatory Microsoft jabs that all Sun employees seem to feel forced to include
in their posts (it’s probably in their employment contract) and the fact that
accusing Microsoft of coming up with non-standard terminology while Java came
with its own term reinvention (why Generics and not Templates?) is quite ironic
in itself, the entire entry is really focused around this simple consideration: 
what are the repercussions of adding invokedynamic to the Java Virtual
Machine?

I’ll let the experts discuss between themselves, but I can’t help making two
observations:

  • Adding a byte code is the ultimate backward compatible change.
     
  • invokedynamic is really not that big a deal.  Groovy, JRuby,
    Jython, and many other existing scripting languages have shown that dynamic
    invocation support at the virtual machine level is not all that important.

Still, it’s quite discouraging to hear from Gilad that should this change be
approved, it wouldn’t make it into Java before the next next (that’s two
"next")
version of Java. Probably at least two years in the future.

And on the other side of the fence, you have Microsoft, which used its own process to find a heir
to the very successful C#:  work behind closed doors and when done, publish
it and tell the world "this is it".

It’s easy to hate this approach, but there is also a lot to like about it. 
While I share some sympathy for Gilad’s fondness of committees (his
words), my experience has taught me that committees just don’t work for
languages.  Successful languages are not created:  they just happen. 
And there’s not much you can do to drive that process.

Does this mean I like all the new C# 3.0 features?  No. And actually, C#
3.0 has so many new features that statistically, you are guaranteed to hate at
least half of them, but this is an approach that has been pretty successful for
C++, and I expect the same success for C# 3.0.

I can’t help giving credit to Microsoft for coming up with so many
innovations and such a rebel attitude.  I am predicting that C# 3.0 will
usher us in the fifth generation language era and that all the features they are
adding to C# 3.0 will be the new reference against which future languages will
be judged.

There is a lot to say about these new features but going over them would make
this post too long, so I’ll save this for a future entry.