A blog about software – researching it, developing it, and contemplating its future.

Bob vs. Gavin, no holds barred

with 3 comments

As this blog chronicles, I was in the Java world from 1996 to 2008. Near the end of the road, I got involved in the Seam and GWT communities, and I met Gavin King and Bob Lee. Gavin developed Hibernate and Seam (both wonderful), and Bob created Guice at Google (which I hear is wonderful, but haven’t looked at it much). (Sorry, can’t be arsed to link all these terms; search = your friend!)

Then we had to sell our house (housing bubble near-miss) and we decided to move to Seattle, and now I work for Microsoft and am very happy, and I lost touch with what was going on in the Java world. The last I heard, Gavin was working on the Web Beans JSR (JSR-299), collaborating closely with Bob, and Web Beans was going to be the best of Seam and the best of Guice standardized and pushing Java EE forwards. Ah, how lovely a picture!

However, I just opened my RSS feed on Gavin’s blog, and was shocked — SHOCKED — to see serious trouble in paradise. For example, quoth Gavin:

Bob, if you’re honestly trying to argue that Guice – which relies upon procedural Java code to specify dependency-related metadata – is as inherently toolable as a system that allows all dependency-related metadata to be specified using annotations (or XML for that matter), I’m just going to leave this discussion now, because that’s absurd.

And quoth Bob (replying to a different post, I’m cherry-picking not summarizing):

This is a little disingenuous. As you know, the lead of a JSR has absolute power. Most leads don’t abuse this power. They listen to their (highly representative) EG, achieve consensus, and very rarely make executive decisions. I think you’ll agree that you are more of a dictator. Yes, you took what you thought were the best ideas from Guice, but I found working with you as a lead and changing your mind on anything to be an exercise in frustration. I can’t count how many hours I wasted convincing you that Seam-style injection was fundamentally flawed only to have you switch to using proxies which have their own set of problems. I even brought Josh Bloch in one time to help settle a debate, but you cursed at and insulted him. I sincerely wish I had that part of my life back. By joining your JSR, Spring would not only validate it, but they’d have to give you absolute power over themselves. Based on my experience, I wouldn’t recommend they do that.

Zow! What’s also strange is that this comment shows up in my RSS feed for Gavin’s page, but I’m not seeing it on the comments web page itself. So if you want to see the fur fly, go straight to the feed.

This is the kind of thing I miss the least about the Java world. I theoretically admire the openness of the JCP/JSR process, and in theory it should lead to better results than a more closed process. But in practice, normal human perversity just gets in the way — the kinds of personalities that drive specs forwards tend to be very focused, and prone to conflict. So now it looks like there are going to be multiple JSRs describing dependency annotations, and the two people who could best work it out seem to be at each others’ throats (as far as their respective specs are concerned). Disappointing.

Neal Gafter recently left Google — and the entire Java world — and came to Microsoft, for similar reasons… he put man-years of work into the Java closures spec, and then it was killed due to backroom political pressure. The Microsoft model is more like, we own everything, and we will do what we think is best. Coming from the Java world, I used to think that made Microsoft the Evil Borg. But now, on the inside, I see there are a lot of benefits to having a single decision point. (Well, God knows there are huge political issues even inside Microsoft, but it’s still an order of magnitude less than the Java world!)


Written by robjellinghaus

2009/05/08 at 18:04

Posted in Uncategorized

3 Responses

Subscribe to comments with RSS.

  1. +1

    Neal Gafter

    2009/05/08 at 23:20

  2. Well, it seems to me that you are mixing political levels here. I propose that, subjectively, the “back-room politics” you refer to are roughly analogous to the internal politics at Microsoft. Which means that the JSR process still has the benefit of supporting an open and visible dialog up to that point – the fact that back-room politics can derail an openly made decision is a flaw that still/just needs to be fixed. Microsoft has the potential to deliver great work because they could side-step the back-room politics and replace it with the gifted benevolent dictator (what Steve Jobs is to Apple) who could prevent the political process from compromising the design.As the years go by, I find myself using more of the work product of small teams lead by visionaries than I do the standardized API’s built by committees.


    2009/05/09 at 21:09

  3. OK, glad I evidently didn’t mis-characterize anything too badly from Neal’s perspective :-)There’s just as much political sausage made at Microsoft as anywhere else, no doubt. But the benevolent dictator model is fairly firmly entrenched — Anders Heljsberg (wow, I knew how to spell that!) is the final arbiter over what goes in C#, period, end of story. Likewise, AFAIK, Don Syme and F#. Agreed completely that benevolent dictatorship is much better than community veto power where language design is concerned.It looks like the comment of Bob’s that I quoted got retro-deleted by Gavin, which is why it doesn’t appear in the RSS feed anymore, even. Oh, well, I’m going to leave it up here. Sorry, Gavin! (Do I smell a bridge burning? We’ll see whether the flames arrive in my email or not….)

    Rob Jellinghaus

    2009/05/11 at 01:49

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

%d bloggers like this: