The content on this site is my own and does not necessarily represent my employer’s positions, strategies or opinions.
|
I usually have several potential blog entries floating around in my head. On them is “Checklist for joining a standards organization.” Per one of my resolutions for 2009, I’m not going to promise that this will ever appear, but one of the most basic issues is that you know where to go to even consider joining a group. Put simply, you need to get a membership form, read it, have your attorney read it, get internal approval, come up with the money, send the money, join the group. There’s more, but it expands from that.
To the very first point, here are some links to where you get membership information for joining some standards groups. There are hundreds of groups, but I’m only going to list a few to get you going. They are meant to be representative and illustrate the range of membership types and governance structures.
For extensive information about participating in standards creation, see Andy Updegrove’s “The Essential Guide to Standards.”
Over in his blog, Arnaud Le Hors has an excellent piece called “A Standards Quality Case Study: W3C.”
With all the fuss about ISO recently, I think people need to remember that important, and sometimes more important, standards work is taking place in standards groups like the W3C, OASIS, IEEE, OMG, and the OAGI. That is, in my opinion, the ultimate stamp of quality and acceptance need not be from the ISO or one of the other I** organizations. It can be but today that evidently is not automatic.
I know that procurement laws may require international standards in some cases. Maybe it’s time to revisit those laws and instead have them relate to quality, openness, and transparency rather than historical working arrangements.
Over the next couple of weeks I plan to publish several entries on “challenges and priorities in 2008″ on a range of topics, some related to work areas of interest, some related to personal ones. I’m kicking this off today with standards.
In 2008, I think that we collectively should …
- Educate more people about what open standards really are and how to distinguish them from standards that are “open” in name and marketing alone.
- Have more patent holders issue non-assertion pledges for open standards similar to what IBM did last July.
- Consolidate intellectual property and standards organization membership rules into a handful of models, and then have some easy process like that employed by the Creative Commons to help choose one.
- Evolve open standards intellectual property licenses and development processes to be more friendly to free and open source. In the same way, increase the involvement of free and open source developers in open standards development.
- Drive further international government adoption of “global standards” such as those produced by the W3C and OASIS. Help governments large and small to understand the importance of global standards in relationship to current policies around formal “international standards.”
- Help more governments adopt open standards policies that emphasize high quality technical work developed by a broad community of stakeholders in a democratic and transparent way, and deprecate de facto standards that reflect single vendor product use.
- Globalize use of common industry-specific open standards. If the world is indeed flat, then we need all players in particular industries using the same standards as much as possible.
- Increase the use of SOA, web services, data format, and business process standards as part of a common framework that should be used by all industries. If we can eliminate redundant or unnecessarily unique low level standards across different industries, we can decrease development costs and delays, and increase information fidelity and innovation opportunities.
- Complete the rejection of Microsoft’s OOXML as a JTC1 (ISO/IEC) proposed standard as a huge, flawed, unneeded, and redundant document format specification that seeks to use the international standards process to perpetuate a single company’s product marketshare.
- Learn important lessons from the OOXML experience, and improve national standards body and international standards organization processes. Here the motto could be the title of the song by The Who “Won’t Get Fooled Again.”
Next Time: “Ten challenges and priorities for free and open source in 2008″
Microsoft and ECMA are now running the Microsoft Office Open XML specification through the ISO process and the first thing up is the contradiction period. This is the time when objections to the specification can be presented and then resolved, if possible. Here are two links to help you understand this.
- “Microsoft/Ecma’s submissions to ISO for Ecma Office Open XML”
The actual specifications are linked to from this post.
WARNING: Do not print these out or many, many trees will have died in vain given the extraordinary length of the Microsoft Office formats.
- “EOOXML — What is a ‘contradiction’ at ISO and what are its procedures?”
This starts to get into details about the many problems with Microsoft Office Open XML as a potential ISO standard. Here’s a blurb from it:
Office Open XML unquestionably duplicates or at least significantly overlaps with the ODF specification; moreover, unlike Office Open XML, OpenDocument incorporates still other standards such as XPath, XLinks, SVG, XForms, and MathML. Office Open XML reinvents the wheel at every turn rather than relying on existing open standards. The failure to implement XPath in Office Open XML is particularly problematic; it makes full fidelity in automated XSL transformations to and from other XML formats next to impossible. That problem creates a contradiction in the ISO sense; full interoperability between ODF and EOOXML applications is infeasible.
Having two contradictory and inconsistent standards for the same problem would only cause user confusion and lack of interoperability. It will also drive up both user and developer expenses, frustrating the ISO goal [PDF] of “one standard, one test, and one conformity assessment procedure accepted everywhere.�
Entries in this series
Also See: An “OOXML is a bad idea” blog entry compendium
Occasionally I get asked why I really care about all the issues around OpenDocument Format (ODF), related standards in this area, office suites, and the shift to Office 2.0. I give the reasons that long time readers of this blog have seen before about real interoperability, innovation from community developed and maintained standards, and so forth. Since people usually don’t expect a life history, I skip some of the bits I’m going to mention now.
When I was a teenager in the 1970s, the only computing facility we had in my suburban New York school was some sort of timesharing system. There we used yellow paper tape to store Basic programs and printing our code and results on a teletype. Later we got really fancy and used a modified Selectric typewriter to write and run APL programs.
I was editor of the school newspaper and our primary method of creating stories was to type them out and then literally cut and paste them onto big sheets to make the final pages. I wrote a program in APL that would create justified columns so that the layouts would look more professional. That is we, didn’t have word processing capability in 1975 but we certainly had text processing.
After my sophomore year of college, I started working for IBM in the summers and there I learned about Script, a document markup language that used “dot commands” to indicate formatting. From there it was on to GML, the generalized markup language, which was the predecessor of SGML, and then XML. I used Script and GML to write user manuals for the software I was writing in our department. At times I thought it was more fun to get the formatting right than write the applications.
In graduate school I was focused on mathematics, but I helped my future wife format her undergraduate thesis using Script. This was in American History, and she very politely told me, more than once, that she didn’t need the fancy boxes I kept putting around things. I think I managed to sneak a few in.
In my own studies I started to get into TeX and then LaTeX for writing mathematics. These are rich enough to control the formatting of whole documents as well as intricate two-dimensional mathematical expressions. TeX has a very rich language and within it you can write macros, or little software routines, to control the formatting. This is by no means WYSIWYG, but anyone could see the formatting instructions and the text and write applications to process them. There were no secret binary formats that had to be licensed from vendors.
In the 1990s I was involved with computational mathematical software and I wrote software to display text and the computed mathematical results. I’ve documented a bit about this experience and the creation of the techexplorer software elsewhere in this blog. We were working toward an idea where we could use formatting to describe mathematical objects. Not just the formatting, however, but we also wanted to describe what the object meant, the so called semantics. The explicit point of this was to come up with a representation of math objects that could be shared between applications. Interoperability was a primary goal from the beginning, and not just something that worked best with one vendor’s products.
The Mathematical Markup Language, used in ODF, was a standard from the W3C that came out of this work. MathML was the creation of many people.
I talked about these ideas in depth in a blog entry in June, 2005, called “Open Document Formats: ‘Open’ must be more than a marketing term.” There is nothing I said then that I do not still believe.
Documents represent the basis for how we store the information that will become our history. Software applications and companies will come and go, market leaders will change, and certainly all of us will be replaced by a new and younger generation of people who think about information in very different ways. The choices we make today are important and will have implications that will play out over a much longer time than the history of word processing and office suites to date.
HTML, SVG, and MathML
Stop Me If You’ve Heard This One Before
Odds and Ends
-
Borland Rejects Five Bids for Tools Unit
“Borland Software Corp. has created a wholly owned subsidiary to run its tools business after an effort to sell the unit failed.”
(tags: borland)
-
Yahoo Music continues DRM-free download experiment | InfoWorld | News | 2006-12-06 | By Peter Sayer, IDG News Service
“Major record labels are starting to look more seriously at MP3 distribution”
(tags: drm mp3 music yahoo)
-
2006 Great Software List Awards at The Great Software List blog
I’m flattered, thanks!
(tags: blog odf opensource)
-
A Call For New Bloggers: Life, TV, Cars, Golf and AJAX! by Blogging Pro
“Some great news today for all of you out there looking to get into blogging, Bloggy Network is on the hunt for some new blood, …”
(tags: blogging)
-
And the desktop Linux survey says…
“The OSDL’s Desktop Working Group recently concluded a survey on what areas of development are most important to desktop Linux users.”
(tags: desktop linux)
-
FreeMind open-source mind mapping app is capable, flexible
“The current version of FreeMind (v0.8.0, available for Windows, Mac OS X and Linux operating systems) is a polished, feature-rich application that can hold its own against just about any commercial competitor in the mind mapping software arena.”
(tags: mindmapping FreeMind opensource software innovation)
AJAX
Office 2.0
ODF
Open Source
MathML
Odds and Ends
Before we go too much further, I want to show you a little bit of XML processing in Python. As we saw in Part 5, we can open up the content.xml component of our ODF file and retrieve the document. For a word processing document, this will include the text as well as style information for formatting. If there are special inclusions like math within the document, these will be held separately in the overall ODF file, listed in the manifest, and then linked to from the main document text. Overall, ODF is organized to logically separate the different structural and semantic aspects of a document.
In Part 5 I pulled out the XML for the content and then hand formatted it to make it easier to read. I also added some line numbers. It would be nice if we could get the formatting, or “pretty printing,” done automatically. I’m going to do this by changing my function a bit and using what is called the DOM, or W3C Document Object Model. Here is the new form of the Python code to read and then print the XML content:
def get_odf_component(odf_file, component_name) :
"""Returns a named component from an ODF file."""
import zipfile
odf_zipfile = zipfile.ZipFile(odf_file, 'r')
component = odf_zipfile.read(component_name)
odf_zipfile.close()
return component
def print_separator() :
print '\n-------------------------------------------------------------------------------'
def print_odf_content(odf_file) :
"""Print the contents of the document content component in an ODF file."""
from xml.dom.minidom import parseString
content = get_odf_component(odf_file, 'content.xml')
print_separator()
print 'The contents of the document content for "' + odf_file + '" is \n'
dom = parseString(content)
print dom.toprettyxml(' ')
dom.unlink()
return content
I refactored, or rearranged, the code a bit to pull out two utility functions that can be used in many places. The function get_odf_component takes the name of an ODF file and the name of a component and then returns that component information. In the case of XML, this will be a string with the XML in it. In previous parts, I repeated this sort of thing in the functions that extracted the manifest, content, and styles. It makes sense to have one function that can handle all of this. I should add some error checking just in case the ODF file does not exist or if the component is not present in the ODF file, but I’ll skip that right now.
Since the output is now getting rather cluttered with all the ODF file statistics and XML, I’ve added a separator line between sections. The print_separator function does that.
An aside: I’ve often seen the words “separate” and “separator” misspelled, usually because people put in an “e” for the first “a”. When I was little my mom told me to remember “a rat” (as in the rodent) and that would help me remember the correct spelling. It’s worked so far.
The lines in print_odf_content that do the new work with the DOM are
from xml.dom.minidom import parseString
...
dom = parseString(content)
print dom.toprettyxml(' ')
dom.unlink()
minidom is a lightweight implementation of the Document Object Model for when you only need to do a few things with XML. Since we’re just nicely printing the XML, it will do just fine. The first line imports, or brings in, the function parseString. This takes a string containing XML (for example, the content of an ODF file) and puts it in an internal form that you can then walk over and manipulate. That internal form is called dom in this example. The internal representation gets rid of all the angle brackets and puts the information into an object that reflects the element structure of the XML, including the inclusion of one element in another, plus some trickier things we haven’t seen yet. Let’s look at a simple example.
In Part 1 I used the simple XML example
<albums>
<album>Another Side of Bob Dylan</album>
<album>Blonde on Blonde</album>
<album>Blood on the Tracks</album>
<album>Bringing It All Back Home</album>
<album>Desire</album>
<album>Good As I Been to You</album>
<album>Highway 61 Revisited</album>
</albums>
Our structure is a tree with one root and it is the albums element. That has 7 children, each of which is an album element with value equal to the name of a Bob Dylan album. If I had gotten fancy, I could have added a more complicated element structure to include other information such as year of release, producer, record company, genre, and so on. All this data can be arranged in a tree. I can walk over the tree looking for different kinds of information, I can change it, and then I can write it out again.
Generally, XML is a format used for exchanging information from one piece of software to another. An application reads in, or parses, the XML and puts into some internal structure or object that it can efficiently process. At that point, the XML is out of the picture though something else might want to use it. The dom is our way of accessing the data in that internal form.
One of the things we can do with this internal representation is to write it right back out again. There are rules in the W3C XML standard about what you can do to add whitespace—blanks, tabs, and newlines—without affecting the meaning of the information. Within those rules we might want to add some extra spaces and lines to make the XML easier to read. This is called “prettyprinting.”
In our function, the expression dom.toprettyxml(' ') takes the internal representation and creates a string with XML in it. The indentation used at each level is two blanks at the beginning of a line, and these get repeated the deeper we go into the nested XML structure. I then simply print out the string. The output isn’t too bad, as we shall see, though very long lines can be created when there are a lot of attributes. It’s intriguing to me to write a prettyprinter with other options such as line numbers and better handling of attributes, but that is somewhat outside the scope of this series.
The final line is dom.unlink(). This is nonintuitive to most people who haven’t done some serious coding. You can think of unlinking as erasing something or at least giving it back so it can be reused for something else. For general XML, the internal representation can be quite involved and not quite exactly a simple tree structure. By explicitly calling unlink I’m telling the Python interpreter that I’m not going to use dom any longer. Most of the time this happens automatically but in this case it needs a little help.
This is called “garbage collection” and removes a great many kinds of programmer errors. The old but wonderful programming language Lisp has garbage collection and, early on, garbage collection was seen as one of the great advantages of Java over C++. It’s a good thing and a fascinating topic in its own right, if you are so inclined (which I am).
With this rewrite of print_odf_content, we’re ready to look again at the content of our ODF file that just contains the character ‘x’. It’s not quite as attractive as what I did by hand in the last part, but it will do.
-------------------------------------------------------------------------------
The contents of the document content for "x-wmc.odt" is
<?xml version="1.0" ?>
<office:document-content office:version="1.0"
xmlns:chart="urn:oasis:names:tc:opendocument:xmlns:chart:1.0"
xmlns:dc="http://purl.org/dc/elements/1.1/"
xmlns:dom="http://www.w3.org/2001/xml-events"
xmlns:dr3d="urn:oasis:names:tc:opendocument:xmlns:dr3d:1.0"
xmlns:draw="urn:oasis:names:tc:opendocument:xmlns:drawing:1.0"
xmlns:fo="urn:oasis:names:tc:opendocument:xmlns:xsl-fo-compatible:1.0"
xmlns:form="urn:oasis:names:tc:opendocument:xmlns:form:1.0"
xmlns:math="http://www.w3.org/1998/Math/MathML"
xmlns:number="urn:oasis:names:tc:opendocument:xmlns:datastyle:1.0"
xmlns:office="urn:oasis:names:tc:opendocument:xmlns:office:1.0"
xmlns:script="urn:oasis:names:tc:opendocument:xmlns:script:1.0"
xmlns:style="urn:oasis:names:tc:opendocument:xmlns:style:1.0"
xmlns:svg="urn:oasis:names:tc:opendocument:xmlns:svg-compatible:1.0"
xmlns:table="urn:oasis:names:tc:opendocument:xmlns:table:1.0"
xmlns:text="urn:oasis:names:tc:opendocument:xmlns:text:1.0"
xmlns:xform="http://www.w3.org/2002/xforms"
xmlns:xlink="http://www.w3.org/1999/xlink"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<office:scripts/>
<office:font-face-decls>
<style:font-face style:name="Tahoma1" svg:font-family="Tahoma"/>
<style:font-face style:font-pitch="variable" style:name="Arial"
svg:font-family="Arial"/>
<style:font-face style:font-pitch="variable" style:name="Tahoma"
svg:font-family="Tahoma"/>
<style:font-face style:font-family-generic="roman" style:font-pitch="variable"
style:name="Times New Roman" svg:font-family="'Times New Roman'"/>
</office:font-face-decls>
<office:automatic-styles/>
<office:body>
<office:text>
<text:sequence-decls>
<text:sequence-decl text:display-outline-level="0" text:name="Illustration"/>
<text:sequence-decl text:display-outline-level="0" text:name="Table"/>
<text:sequence-decl text:display-outline-level="0" text:name="Text"/>
<text:sequence-decl text:display-outline-level="0" text:name="Drawing"/>
</text:sequence-decls>
<text:p text:style-name="Standard">
x
</text:p>
</office:text>
</office:body>
</office:document-content>
Confession: I broke up the list of attributes by hand onto multiple lines so it would look right in a browser, but that’s all I did by hand. Really.
Now let’s change our ODF file a bit and see what happens to the XML. I’m going to make my ‘x’ bold and increase the font size from the default of 12 points to an explicit 20 points.
<?xml version="1.0" ?>
<office:document-content office:version="1.0"
xmlns:chart="urn:oasis:names:tc:opendocument:xmlns:chart:1.0"
xmlns:dc="http://purl.org/dc/elements/1.1/"
xmlns:dom="http://www.w3.org/2001/xml-events"
xmlns:dr3d="urn:oasis:names:tc:opendocument:xmlns:dr3d:1.0"
xmlns:draw="urn:oasis:names:tc:opendocument:xmlns:drawing:1.0"
xmlns:fo="urn:oasis:names:tc:opendocument:xmlns:xsl-fo-compatible:1.0"
xmlns:form="urn:oasis:names:tc:opendocument:xmlns:form:1.0"
xmlns:math="http://www.w3.org/1998/Math/MathML"
xmlns:number="urn:oasis:names:tc:opendocument:xmlns:datastyle:1.0"
xmlns:office="urn:oasis:names:tc:opendocument:xmlns:office:1.0"
xmlns:script="urn:oasis:names:tc:opendocument:xmlns:script:1.0"
xmlns:style="urn:oasis:names:tc:opendocument:xmlns:style:1.0"
xmlns:svg="urn:oasis:names:tc:opendocument:xmlns:svg-compatible:1.0"
xmlns:table="urn:oasis:names:tc:opendocument:xmlns:table:1.0"
xmlns:text="urn:oasis:names:tc:opendocument:xmlns:text:1.0"
xmlns:xform="http://www.w3.org/2002/xforms"
xmlns:xlink="http://www.w3.org/1999/xlink"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<office:scripts/>
<office:font-face-decls>
<style:font-face style:name="Tahoma1" svg:font-family="Tahoma"/>
<style:font-face style:font-pitch="variable" style:name="Arial"
svg:font-family="Arial"/>
<style:font-face style:font-pitch="variable" style:name="Tahoma"
svg:font-family="Tahoma"/>
<style:font-face style:font-family-generic="roman" style:font-pitch="variable"
style:name="Times New Roman" svg:font-family="'Times New Roman'"/>
</office:font-face-decls>
<office:automatic-styles>
<style:style style:family="paragraph" style:name="P1"
style:parent-style-name="Standard">
<style:text-properties fo:font-size="20pt" fo:font-weight="bold"
style:font-size-asian="20pt" style:font-size-complex="20pt"
style:font-weight-asian="bold" style:font-weight-complex="bold"/>
</style:style>
</office:automatic-styles>
<office:body>
<office:text>
<text:sequence-decls>
<text:sequence-decl text:display-outline-level="0" text:name="Illustration"/>
<text:sequence-decl text:display-outline-level="0" text:name="Table"/>
<text:sequence-decl text:display-outline-level="0" text:name="Text"/>
<text:sequence-decl text:display-outline-level="0" text:name="Drawing"/>
</text:sequence-decls>
<text:p text:style-name="P1">
x
</text:p>
</office:text>
</office:body>
</office:document-content>
There are two changes from the plain version above. The first is where we went from
<text:p text:style-name="Standard">
x
</text:p>
to
<text:p text:style-name="P1">
x
</text:p>
As I explained last time, Standard is a named style that just has the default paragraph formatting. In this case, we have a new style called P1. If we go up and look at the automatic styles, we started with
<office:automatic-styles/>
That is, no automatic styles, to
<office:automatic-styles>
<style:style style:family="paragraph" style:name="P1"
style:parent-style-name="Standard">
<style:text-properties fo:font-size="20pt" fo:font-weight="bold"
style:font-size-asian="20pt" style:font-size-complex="20pt"
style:font-weight-asian="bold" style:font-weight-complex="bold"/>
</style:style>
</office:automatic-styles>
An automatic style is created when you simply make individual formatting changes. Here the ‘P’ in P1 is for “paragraph.” You can see that this has as parent the previous Standard style we discussed. It inherits all the formatting properties from the parent. If we were to make a change to Standard, those changes would be reflected in P1 unless they were somehow overwritten.
If you look at the rest of the definition of P1, you will see how the font is made bold and the size is now 20 points. Incidentally, there are 72 points to an inch. A point is an old typesetter measurement.
The actual structure of the document near ‘x’ has changed very little, just a little change of style name. All the actual style information is kept somewhere else and so the document is kept nice and clean. Nice design, if you ask me.
Next time we’ll examine more serious changes to the document and see how they are reflected in the XML.
Parts: 1 2 3 4 5 6 7
Also see: “Regarding use of the Python code in my blog entries”
I’ve been somewhat remiss lately in adding some links, so this should bring me up to date.
Open Source
DRM and Microsoft
ODF
Accessibility
Music
Politics
Fun
Over in his blog, IBM’s Rob Weir further delves into the underlying specifications Microsoft uses in their office XML spec and their almost pathological avoidance of accepted industry standards created by experts in what they are doing in ECMA.
In this installment, “Math You Can’t Use”, Rob looks at how Microsoft didn’t bother to implement MathML but rather just rolled their own way of representing mathematical objects. Even though MathML was one of the first specs built on the then new XML standard at the W3C, even though it was created by people who collectively had tens if not hundreds of years writing a broad range of mathematical software, and even though it was co-led by someone who worked for the American Mathematical Society, Microsoft didn’t bother to use it. Instead we’re stuck with their own flavor of formatting math objects. On some days I’m surprised that they’re even using XML at all.
I take this somewhat personally since I was a co-author of MathML, but I’m not really bitter about it. I just shake my head over this repeated behavior of making bad choices to avoid true industry standards. If I were writing mathematical software today, why would I possibly want to expend the energy to implement Microsoft’s spec when there is a really good, mature, tested open standard otherwise available? And, by the way, I can use that open standard to format my math objects for use in many applications, not just for a word processor. No thank you.
Microsoft’s avoidance of a real standard here means extra work for developers out there. This slows down development. This raises the cost of implementations. This is unnecessary extra work. No thank you.
By the way, when you see something like x3+2 do you know exactly what it is? Well, it looks like a polynomial with two terms (x3 and 2). Is 2 an integer or something else? In mathematics there are many algebraic structures that share some similar properties with the integers or the rational numbers, but are not those same things. Consider the rational numbers. These look like a/b where a and b are integers and b does not equal 0. By letting b equal 1, we see that the integers are embedded in the rational numbers.
For convenience and uniqueness we take out any common factors in a and b and write the denominator without a minus sign. That means we write 6/8 as 3/4 and rather than 1/(-2) we write -1/2. You can add or multiply any two rational numbers in any order. If you add 0 to any rational number you get the number back. If you multiply 1 by any rational number you get the number back.
Given a/b and the conventions above, there is just one number that you can add to this to get 0, namely -a/b. If a does not equal 0 and we use the conventions above, there is just one number that you can multiply it by to get 1, namely b/a. This means that every non-zero element in a field has a multiplicative inverse. You can divide a rational number by a non-zero rational number and get another rational number. That is, the collection of rational numbers constitutes what mathematicians call a field.
There are an infinite number of rational numbers. We can find fields that only have a finite number of elements. For example, imagine the field with three elements 0, 1, and 2 with the following rule: after multiplying or adding, the answer is the remainder after dividing by 3.
So we see that 1 + 1 = 2, but 1 + 2 = 3 and after taking the remainder after division by 3, we get 0. So 1 + 2 = 0. In this field we have -1 = 2!
In the same way we have 2 + 2 = 2 * 2 = 1. So both 1 and 2 have themselves as their own multiplicative inverses.
Let’s get back to x3+2. Is that 2 an integer, a rational number, an element of the field with three elements, or something else? It affects what we can do with x3+2. If 2 is an integer then if we square the polynomial we get x6+4x3+4. If 2 is in the field with three elements we get x6+x3+1. These are different animals.
There many different fields that arise in mathematics and physics and they are important to how we model the universe and do computations. They’re really not curiosities: they’re fundamental concepts in how we understand (or think we understand) how things work. A field is just one example of an algebraic structure. There are many others.
I went through this rather pedantic digression to show that how you represent a mathematical object is extremely important. There is more to what you need to know about a mathematical object than what it takes to make it look pretty in a word processor. MathML was developed by people who understood mathematics, understood computation, understood software, and understood publishing.
It’s a shame that Microsoft decided to ignore them. It’s a bigger shame that anyone would try to create a new standard by incorporating old, self-created specifications that have already lost. I’m not bitter, I’m just shaking my head in disappointed amazement.
Rob Weir’s latest blog entry “Cum mortuis in lingua mortua” delves into VML, an old Microsoft spec that went out of fashion and acceptance years ago, and SVG, a W3C spec that has been a standard for 5 years.
Would you be surprised that the ECMA MOO-XML spec uses VML?
Guess which one ODF uses?
The W3C has finalized its approval of the XForms 1.0 (Second Edition) Recommendation. The spec itself is here. This hasn’t hot the news media to any large degree, but it is nevertheless an important development. I suspect XForms will be a future standards battleground, though I think that it will steadly gain favor because of its use in things like ODF. Here are a few articles that discuss XForms:
Finally, the book XForms Essentials is available online. Start here.
Tim Bray has an entry over on his ongoing blog about AJAX and how it enables certain optimizations that just straight up make sense. The other reason I mention this is because Tim is the husband of Lauren Wood, the extremely patient and talented woman who chaired the W3C Document Object Model (DOM) working group. The DOM is now one of the key technologies that makes AJAX work.
I was a fringe member of the DOM wg for a couple of years and I can attest to her being able to bring together sometimes testy competitors to come up with something that we all can use. It’s a great success story for open standards vs. vendor-directed specifications, in my opinion. One of these days Lauren will get an industry award that recognizes her contribution to this important new technology.
Here are a couple of interesting links regarding the Microsoft XML Formats and their move to ECMA.
- ECMA is basically a RAND (reasonable and non-discriminatory licensing) organization, vs., say the W3C, which RF (royalty free). While Microsoft has issued a covenant not to sue, what will the situation be for the other participants? Will it be RAND or RF? We should not assume that just because the specs are coming from Microsoft that they are the only one who might have intellectual property that relates to it.
- Miguel de Icaza mentions in his blog that the ECMA technical committee TC45 has already been created.
- Evidently Novell plans to participate in the ECMA committee to ensure office-to-office interoperability. They say that they “are happy to participate with the ECMA review group to ensure the specification that results is complete enough that it allows for alternative office suites to interoperate with the Office Open XML file format.”
Thanks to Sam Ruby for the links to the last two items.
Update: IBM’s Michael Breidthardt notes in the comments “The formal decision to create ECMA TC 45 will be taken at the Ecma General Assembly on December 8, 2005. Such a decision will be done by simple majority of Ordinary Member’s of Ecma.”
|
|
