OOXML means Open Office Office Open eXtensible Markup Language XML. It is a version of XML more generally.

DOCX is the filename extension for files of the OOXML format. This is only important for Windows machines which use extensions to identify the file type. (Which decades ago may have seemed like a good idea, as did storing dates in a format that would not work past midnight, December 31st, 1999).

ODF is Open Document Format, a standard developed by the OpenSource community and used as the default file format for OpenOffice, for example.

UFDA is one of the many ways to spell “oofda” … which is what we say in Minnesota just before getting a hernia.

A markup language is a set of codes and conventions that are used to modify a text file so that it looks a certain way when rendered (made, generated, shown) on an output device such as a screen or printer.

For instance, a markup language may be used thusly:

What the heck are you talking about.

could be marked up like this:

What the {start-shout}heck{end-shout} are you talking about.

so that on a computer screen it would look like this:

What the

HECK

are you talking about.

and when rendered on an audio output device, i.e., a reader for the sightless, it would say all the words normally but the word “heck” would be much louder than the other words.

That was a made-up example. I could have used one of the common markup languages such as HTML to show an example, but perhaps your browser would take my code seriously and your computer would be shouting at you and you would miss the point….

… that point being that markup language can be interpreted in different ways, as appropriate, by different devices, such as the computer screen showing large, bold type and an audio machine raising its voice, with the same basic encoding. This works because there is a standard for the markup language that the devices (including software) “know” about.

XML is a markup language developed by W3C, the World Wide Web Consortium. The W3C works tirelessly (I assume) to make sure that XML, as it is further developed and evolved, does not break in some way that might obviate its fundamental purpose: Being readable, useful, and open in design.

One way this is done is through the concept of “valid” code. A document using XML is valid if certain conditions are met. A valid document can be interpreted by any proper XML-reading software partly because there is a standard and partly because some of the information about the markup is actually contained in the document itself. So if you want to do something freaky, like have the computer beep every time a certain word is rendered on the screen, you can probably do that, but not by changing the standard. You do it by adding this specification into part of the document itself.

For this to be OpenSource, you could not have the beeping effect require the user of the document to purchase a product that makes this document-to-hardware link happen. It has to be something that can actually happen on any machine across platforms.

The W3C XML standard has been further adopted by other standards-managing entities, such as ISO or ANSI as well as governmental institutions such as the European Union or the British BSI. This sort of standards-related activity, which makes the World Wide Web go-round, is time consuming and intense, and is often going on behind the scenes, but is very important for things to actually work. It is a little like there being standards for, say, gasoline. What an “octane” means, and what is actually in gasoline, and so on, is regulated. Therefore you know that when you pump gasoline into your tank you will be getting essentially the same thing each time. Car manufacturers could not really make cars if pumps provided a wide range of liquids with no standardization.

Now, what about OOXML?

The main and most salient issue with OOXML (Microsoft’s “DOCX” format) is simply that it is not approved as a standard pretty much by anyone. Until a standard is approved, it should not be used. But if you are Microsoft you can do whatever you want because you are the standard. Microsoft is the standard because it is big and powerful and very good at crushing anyone in the US who disagrees with it. It is not so good at this overseas, and those sorts of lawsuits that tend to fail against Microsoft or get watered down in the US tend to do real damage overseas. In the international sphere, Microsoft is to the computer world what George Bush is to the social and political world. Everybody hates America and Americans because of George Bush and the War in Iraq, unless you are an IT professional or geek, in which case you also hate America because of Microsoft and Bill Gates. This is one reason why there is so much development of and use of OpenSource products and the Linux operating system overseas, percentage-wise, compared to here.

Using OOXML and accepting it as a de facto standard because it is made by Microsoft is a little like using a drug that is not approved by the FDA but is a de facto standard because it is made by a giant pharmaceutical firm that has the power to crush opposition in any form. Would you do that?

But alas, I am starting to digress (sort of). What is wrong with OOXML other than being equivalent to the feces of Satan?

In other words, maybe OOXML is a great standard, and everyone should use it, and the OpenSource world needs to stop bellyaching about it and just admit that something good came out of Microsoft.

There are at least two reasons why I strongly suspect this is not true without even looking at the OOXML specifications. First, I don’t trust Microsoft to not have a nefarious, self serving, crush the competition, etc., plan in mind. Second, when I read commentary by known Microsoft-Simps regarding OOXML, none of them say that the standard is good, acceptable, or not bad. They speak only of politics and such, not the actual code. If the code was clearly excellent or perhaps even better than existing XML file formats, then why would they not mention it?

But that is not satisfying, and I do not consider it a tenable position. So it is not really my position, just my suspicion. My position based entirely on this suspicion is this: Until OOXML is an accepted standard, then don’t send me any *.DOCX files! At a later time, when the standard is approved just like all the other standards, and my OpenSource software can seamlessly read and write to these files, as it does to all other Microsoft formats, then we can talk. In the meantime, keep your stinking DOCX away from me!

But wait, there’s more ….

I have looked at the specifications and commentary about the specs. I cannot honestly say that I’m in a position to evaluate the qualities of OOXML vs ODF or other XML documents. But there are reasons to suspect, other than faith in the evil nature of Microsoft, that OOXML is a) broken and b) nefarious.

For instance, an XML standard either follows known standard conventions and/or includes the details necessary to make a markup code function properly. Refer to my example of making your computer beep (above). Microsoft OOXML includes a large number of formatting related XML code items that are NOT defined in the standard or the document, and that will only function if the document is either read by a very current version of Microsoft Word or by an as yet unavailable translator or other software that has been reverse engineered to crack the code.

So the word “open” in OOXML is morally equivalent to … oh, don’t get me started with the disturbing metaphors…

Another problem with OOXML is that it does not reflect existing, extant best practices. It is to a large extent a re-design, rather than an evolutionary advancement over pre-existing designs for markup. This could be brilliant. Maybe the efforts of a zillion people over a zillion number of person-hours have resulted in things we call “best practices” but are actually uninspired gobblygook, and Microsoft has offered a total redesign that is an improvement in most or all ways. Or maybe not.

This is not merely conjecture. One of the subsets of an XML standard is how vector graphics are handled. Years ago there were two standards (among others, I’m sure) for managing vector graphics: VML and SVG. The various standards committees saw VML as inferior to SVG and thus the latter was adopted as the standard. No, this is not a “Beta vs. VHS” thing, where (according to current belief, but not necessarily true) “Beta” was actually better but VHS won out anyway. VML sucked SVG was good. The standards committee people are very well aware of the Beta/VHS phenomenon, and they make their decisions based on real things.

Microsoft’s OOXML, however, uses VML rather than SVG. This could be because VML was a standard originally developed by (and for all I know, “owned” by) guess who. Microsoft. So, is OOXML’s use of this old, rejected standard rather than Best Practices Approved SVG is perhaps because: a) Microsoft knows better and knows they know better, and thus sticks with its old idea?; b) Microsoft has a lot of VML experts around and has not really gotten on board with SVG, and thus is willing to throw away quality and standards-based development because it is convenient?; or c) Microsoft owns VML in some patent or trademark related way and thus plans on some nefarious Engulf and Devour strategy later on when OOXML is in widespread use? I don’t know which if any of these is true. I’m just sayin’ …

There are other problems with OOXML. The way it handles dates is strange and will cause problems. There is a new kind of string variable defined in OOXML (a string variable is where you might put words or letters and stuff). This variable allows the existence, in the “string” of characters, of little doohinkies called control characters that are normally never allowed in such form in XML documents. This means that standards compliance software reading OOXML documents could break. Break the document, break the software, break your hardware, or break your security. OOXML uses other conventions that are out of date and never used, for good reasons, in XML documents, such as bitmasks, and binary print specifications. Some of these quirks don’t even conform to Microsoft’s current standard practices.

So, no, it is probably not just sour grapes. OOXML might actually suck. And it is evil.

Ufda.