On timing and developers’ethic

Dear readers,

I would first like to wish you a Merry Christmas and a Happy New Year. 2008 will be exciting, but most of you already know it.

Today I would like to tell you about something I have discussed here and on several other places, such as mailing lists. It is a key issue as it relates both to the topic of open standards, format adoption, and FOSS. It is intensely political, but also has some very real implications. This article by Bruce Byfield prompted me to discuss these matters in a more detailed fashion.

What is this all about? The Gnome Foundation’s behaviour in front of the OOXML controversy. I don’t think there is any need to remind my audience on what happened with the Gnome Foundation (the article above will summarize things well). Suffice to say, Novell and/or ex-Novell developers have been assisting to the Ecma TC 45 (the one on OOXML) and been “supportive” of OOXML in general. I am aware that I’m making a very long story short here. But I’m doing this on purpose: the conspiracy that Bruce refers could be summarized as Novell engineers hijacking Gnome to serve their own corporate needs, and the problem is, these needs are aligned with the ones of Microsoft.

That is one perception of the story. I am not saying it is true, at least not at the moment.  Yet it is shared by the greatest part of the community, at least the one that has heard of that story. I am a bit surprized by Bruce’s opinion. His take on the subject is that although one doesn’t have to be an OOXML fan, there is no reason why we should be pragmatical. This kind of argument is something I have witnessed ever since the agreement between Novell and Microsoft have been signed. It has been floating in the general buzz and you find it everywhere where Novell goes. You have to be pragmatic. Not idealistic. You’re in the business. In this industry. Sure, you’re selling Open Source (how can we sell that is a different story, entirely), but you’re reasonable. And above all, you serve your customers first and give them what they want.

How to make a FOSS developer swallow that he’s indeed working for Microsoft

I have noticed that there is some kind of snobism being expressed by several developers in regard of non-developers. Most of this is usually expressed along the good old lines of the cognoscenti versus the ignoranti (the non developers, the laymen). What I find interesting is that -talking about OpenOffice.org- this kind of behaviour is usually found with some Novell developers. I’m not throwing mud at Novell here, I’m talking characters and persons. If they feel it’s an ad hominem attack, so long for them, I have no time to lose. Their speech and what they implicitly state can be broken into several constant and well-identified parts:

– We are software engineers. We are in the know. You are not

– We know how to code. You don’t. We are wizards to you

– We do not care about politics. We are solely absorbed by our art.

– Anything else out of the code is blatantly insignificant.

On a psychological point of view , one could have many things to say. The code is sacred, and we have the knowledge. We instigate ourselves as the rulers of the community through our sheer power we have gained through our knowledge. We shall rule the community (a polite word for this is “meritocracy”).

There are however several problems with that. The first one is that this kind of behaviour not only frustrates non coders, but it also ignores a deep reality of Free Software communities: Users have as much right as developers have, and non-developers can contribute as well, sometimes in ways that are more important than code, as code in itself can often, if not always, be a commodity.

The second problem is more subtle  and is directly related with the OOXML controversy. You can flatter developers with this kind of opinions, and it will be easy for them to forget about those damned “politics”. For instance, I was very surprized one day when I asked -politely-  a question about wether OpenOffice.org should move to a different license, such as, for instance, the (L)GPL v3. All of a sudden several developers -all Novell employees- jumped on me and started to explain that 1° this was all politics 2° I was bringing this topic just to bother them. I was surprized because to this day I still do not understand why this could have been a problem. There needs to be a deep and meaningful conversation about moving to the (L)GPL v3 to be sure, but not one where Novell or, more simply, engineers should feel bothered or cricitized. After all, it’s their software too.

Hence, we could think of a group of developers whose egos would be flattered and petted so nicely they’d start to think they are half-gods on the Earth and who would, because of how professional they are, leave the discussion on politics and law to the specialists, because they are reasonable.  The point of course would be to know who these specialists would be working for. I do hear very well that developers are not lawyers, and that lawyers not developers. So you need to ask specialists sometimes. That does sound obvious to me. But there’s a difference between good sense and good rethoric. I think that’s how the problem with Gnome, OOXML and some employees or ex-employees of Novell started.

Formats and Network effects

It is not necessary at this point to tell the story of Microsoft Office and how it became ubiquitous. But it may be worth explaining how network effects work in the realm of office suites.

Take three office suites: A office, B office, and C office. A office is that very successful office suite everyone has come to love and use; everyone, that is, the people working in the office. A office is in some sense an entreprise software.  B office is a less-known office suite, with a smaller market share. C office is the underdog. Each office suite uses its own format, format A for A office, B for B office, C for C office. At this stage, conversion and exchange of documents between those three office suites are very difficult, and only can only work between users of the same product.Needless to say, formats A, B and C are completely closed and non standard.

Now watch this: B office strikes a major deal with 5 of the largest PC manufacturers and will be pre-installed on every computer sold by any of those 5 vendors. People soon find out that they have an office suite, that it’s not as bad as it may seem in comparison of A office. B office has some good converters, so transition is easier than expected. By striking this deal, B office gains a much larger user base than A office in a short period of time. But there’s more: as more and more people buy PCs, the format B becomes used more and more and every day. At some point, users of A office and C office are being requested that they should use format B for convenience. Unfortunately for them, the benefits that come with using A or C office are vanishing quickly, and many of A or C office customers are switching to B office because it becomes harder to use A or C office, harder to use because of the formats, and harder to purchase. Now we reach a stage where C office is on the verge of going bankrupt. They take the decision to support format B in the hope that customers will go back to them and that they will be able to benefit from the network effect of B office. Problem is, format B is closed, and C office developers have to reverse-engineer format B, releasing a pretty good, but flawed and crippled conversion filter for C office. Result: C office buys a bit more oxygen, but dies two years afterwards, without anybody noticing. Meanwhile, A office refuses to adopt format B and extends its features set by integrating new software that does not belong to an office suite, while changing its distribution channels. The network effect though, still plays against A office and it is forced, under customer pressure, to implement a conversion filter with format B. The result is that A office moves up the applications stack and becomes a different product, like a mail and calendar server,  a PIM, or even a application server. But it ceases to exist as a meaningful office suite alternative on the market in a short period of time. That is roughly how network effects work in the business of office suites. The most important lesson of this is that what matters is the format, not the application. The format creates the network effect and captures users, unless it is open and standard. Now, I think Gnome and Novell developers (aside perhaps Miguel De Icaza), the Noooxml web site, the boycottnovell.com web site and myself can respectuously agree on one point: OOXML is neither open, nor standard. Thus, we should not be helping it in anyway, I could add. But here’s the catch:

You have to be reasonable.  Microsoft dominance on the office suite market is such that you cannot avoid them. Hence, we are developing OOXML plugins and an export filter for our own version of OpenOffice.org. 

Does this make sense to you? It does to me, but there is a syllogism in the propositions above. I agree with being reasonable, although I don’t know what it means in this context. I agree with the reality of Microsoft dominance on the office suite market (hey, everyone does) but I don’t agree with the last sentence, neither with the project, nor with the apparently logical relationship between Microsoft dominance and the project. What this means is that you are effectively extending Microsoft’s grip on the office suite market simply by extending the use and the reach of their new format.

Resistance is futile!

Where this story becomes wild is when you consider the timing of OOXML and the development of plugins and converters. It should perhaps be important to remind my readers that to this day, MS/Ecma/whoever OOXML is not an ISO standard. In fact, it’s far to be one, and major modifications could amend its specification. That’s the unfortunate and often overlooked part of the story: some developers have been rushing to extend the reach of a closed and half-finished format before it was even adopted by the users of its main implementation. And there one may wonder if it wasn’t in a sense a very good deal for Free Software and Open Standards. By being proactive, the Novell team is gaining skills and understanding of the format beforehand.

I think this argument is actually quite pernicious. First, they will not gain any understanding of anything if Microsoft decides not to use OOXML (amended, post BRM, 2008 version) in MS Office 2007. If you think it would be a foolish option, then I suggest you ask Microsoft how they managed to implement both an XML and a closed , binary format for Excel 2007 bearing the same extension. And if you’re a lawyer, it will not take you long to realize that Microsoft has no obligation to use OOXML in MS Office or any of its products. Actually, that stands true for any format, standard or not standard. Second, the theory according to which you can cooperate with your ennemy in order to avoid confrontation works sometimes and only to a certain point. I have seen some critics of OpenOffice.org explaining that OpenOffice.org was not being legally covered by the Sun-MS covenant. It’s actually being protected by the OIN, of which my company is a licensee, but that’s not the question. Now think about this: Novell does interact and could/has/may use Microsoft’s IP when working on the export filters to OOXML for OpenOffice.org. On a legal point of view, nothing could stop Microsoft to sue OpenOffice.org if it ever was to use the OOXML export filter developed by Novell…. unless you use the Novell edition of OpenOffice.org.  Now how good is the argument about cooperating with your ennemy?

So why does one even bother with OOXML? That’s the question Jody Goldberg, Miguel de Icaza and some others should answer to. And I hope this time it will be better than “a technical interest in the matter”. My take on this is actually very simple and actually quite reasonable: It’s all about money and business. Surprized?

There shall be no middleground

Bruce Byfield’s article emphasizes on the Gnome Foundation’s involvement in this  controversy. I think it would be inaccurate and unfair to the Gnome Foundation to claim it has sided with the OOXML camp or anything of this kind. It would be factually wrong, and would hurt the feelings of hundreds of contributors. In this, Bruce is right to balance what has been heard here and there, but perhaps Bruce could have read the fineprint better: what I’ve read on the websites he qualifies to be “cherry picking” does cast doubt on some members of the Gnome project, not so much on the Foundation itself.

The Gnome Foundation is composed of many developers from large or small corporations that are either hostile or simply indifferent to OOXML. What may have happened was flamewars that ended up in a pretty ugly way, as flamewars always do. I think we will never know how Novell employees and an ex-Novell employee managed to lure Gnome into the Ecma. Jeff Waugh seems to be a perfectly reasonable gentleman who may have been in the unfortunate position of listening too much to some of its contributors. Aside of that, Jeff clearly expressed that the Gnome Foundation does not endorse and will not endorse in any way OOXML. That being said, this is Free Software, and if some still want to try to implement OOXML, that’s their choice.

Bruce’s article states several time the need of finding a common ground. I agree with him once again that there should be a reconciliation with the Gnome Foundation. But there will be no reconcilation possible with the backers of OOXML. I would even point out that there is no need for that. Why, for instance, should the Gnome Foundation sponsor Jody’s participation to the Ecma? What good does it do to Gnome and to Free Software in general?

Open Standards can be a very complex topic, but there is one thing that, despite many discussions, shall remain clear: You cannot be a little open, and a little standard. More exactly, a standard is either an ISO standard or not an ISO standard. Although several definitions have been given for an open standard and several others will appear in the future, openness can always be measured in terms of lack of barriers. To this day, OOXML is neither standard, and far to be open. The fake common sense argument that makes a partly published specification an “open” specification has lured many into believing half-truths, but since then many have realized how closed and incomplete it was. Apparently some would still like us to believe OOXML is an open standard. Make no mistake, OOXML is not an open standard, just like Christmas is not Easter.