Andy Oliver writes about the interplay of standards and Open Source. One of his claims is that

Most standards are needless attempts to make it so that "anyone" can work in an area of complexity.

This doesn't match my experience on standards. First of all, if you look at a lot of standards, they are very complicated, particularly in the XML space that he uses as an example. My personal favorite in this area is XML Schema, since I had a view into the evolution of XML Schema. I wrote the first implementation of XML Schema validation for Xerces-J, and had to try to keep up with the changes as XML Schema went through the W3C process. Many of the XML standards are overly complicated, and only getting more complicated. There's no way this is helping "anyone" work more effectively.

The other experience that I've had is that people want to use something "standard" as protection against vendor lock-in. Before open source really took off, standards were a kind of protection against lock-in, if everyone implemented the standards correctly. This just pushes the problem to the level of "did the vendor implement the standard correctly". Hence the XML conformance suites and the TCK's for every JSR under the Sun. I think that standards (as created by standards bodies) are no longer the only protection against vendor lock-in. Today, open-source implementations of good ideas can serve as protection against vendor lock-in. If you can get the source, you can do what you want with it, and you can adapt your system to a new vendor since you have the source. Just look at all the Jakarta stuff that is being ported to .NET if you don't believe that.

Open source implementations of good ideas can become de-facto standards - look at Log4J (so good it got standardized into the JDK), JUnit, Struts, as examples. This means that we no longer have to be held hostage to design by committee standards. My issue with standardization is that right now we are seeing a lot of premature standardization. In a standards based world, being the author of a standard is a competitive advantage. If you're a big company, making the standard so complicated that only big companies can implement it is a way to keep competitors out of the market. So we're seeing a rush to standardize stuff that we don't really understand, or we're standardizing just plain bad stuff.

At Apache, we've focused on implementing standards. The common wisdom is that success of HTTPD is due to a high quality implementation of HTTP. That common wisdom was applied to the creation of the XML project and the Web Services project. We've been successful at that. At the same time, we've become foot soldiers in the standardization battles. I believe the that open source community, has the ability to set defacto standards by producing great ideas and open sourcing the implementations. No one needed a Log4J standard in order to start using Log4J. No one needed an Ant standard to start using Ant. At the same time, it's hard to find a Java project that doesn't use Log4J (or one of its intellectual ancestors) or Ant. Ant has even crossed over to .NET. Why should we limit ourselves to implementing bloated, inefficient standards? We have the influence to create our own. May the best idea win.

Some excerpts from Matt Mower:

MultiJava is an open project to add open classes and symmetric multiple dispatch to Java.
...
In concert with AspectJ this would appear to add some very powerful capabilities to Java.
...
Of course Greenspun might argue that you should just use Lisp in the first place... ;-)