Category Archives: Standards development

Notes from the belly of the beast

Scenes from a Recommendation 3: Boston, Prudential Tower

Posted on by

Another memory from the development of XML.

It’s November 1996, at the GCA SGML ’96 conference, at the Sheraton in Boston. The SGML on the Web Working Group and ERB have just been through an exhausting and exhilarating few weeks, when from a standing start we prepared the first public working draft of XML. At this conference, we have been given a slot for late-breaking news and will give the first public presentation of our work.

Lou Burnard, of Oxford University Computing Services, the founder of the Oxford Text Archive, is there to give an opening plenary talk about the British National Corpus, a 100-million-word representative corpus of British English, tagged in SGML. Lou and I are old friends; since 1988 we have worked together as editors of the Guidelines of the Text Encoding Initiative. Working together to shepherd a couple dozen working groups and task forces full of recalcitrant academics and other-worldly text theorists (“but why should a stanza have to contain lines of verse? I can perfectly well imagine a stanza containing no lines at all”) from requirements to draft proposals, to turn their wildly inconsistent and incomplete results into something resembling a coherent set of rules for encoding textual material likely to be useful to scholarship, and to produce in the end 1500 pages of mostly coherent prose documentation for the TEI encoding scheme, Lou and I have been effectively joined at the hip for years. We have consumed large quantities of good Scotch whisky together, and some quantities of beer and not so good whisky. We have told each other our life stories, in a state of sufficient inebriation that neither of us remembers any details beyond our shared admiration for Frank Zappa. We have sympathized with each other in our struggles with our respective managements; we have supported each other in working group and steering committee meetings; we have pissed each other off repeatedly, and learned, with a little help from our friends (thank you, Elaine), to patch things up and keep going. No one but my wife knew me better than Lou; no one but my wife could push my buttons and enrage me more effectively. (And she didn’t push those buttons nearly as often as Lou did.)

Tim Bray is also there, naturally. He and I have not worked together nearly as long as Lou and I have, but the compressed schedule and the intensity of the XML work have made it a similarly close relationship. We spend time on the phone arguing about the best way to define this feature or that, or counting noses to see which way a forthcoming decision is likely to come out (we liked to try to draft wording in advance of the decisions, when possible). We commiserate when Charles Goldfarb calls and spends a couple hours trying to wear us down on the technical issue of the day. (Fortunately, Charles called Tim and Jon Bosak more often than me. Either he decided he couldn’t wear me down, or he concluded I was a lightweight not worth worrying about. I’m not complaining.) Like Lou, Tim often reads a passage I have drafted and says “This is way too complicated, let’s just leave this, and this, and this, and that, out. See? Now it’s a lot simpler.”

At one point I believed it was generally a good idea for an editorial team to have a minimalist and a maximalist yoked together: the maximalist gets you the functionality you need, and the minimalist keeps it from being much more than you need. Maybe it is a good idea in general. Or maybe it was just that it worked well both in the TEI and in XML. At the very least, it’s suggestive that in the work on the XML Schema spec, I was the resident minimalist; if in any working group I am the minimalist, it’s a good bet that the product of that WG will be regarded as baroque by most readers.

It’s the evening before the conference proper, and there is a reception for attendees in a lounge at the top of the Prudential Tower. I am standing chatting with Tim Bray and Lauren Wood, and suddenly Lou comes striding urgently across the room towards us. He reaches us. He looks at me; he looks at Tim; and he says, in pitch-perfect tones of the injured spouse, “So this is the other editor you’ve been seeing behind my back!”

Scenes from a Recommendation 2: subtle and devious

Posted on by

Tim Bray’s prose sketch of Jon Bosak is good, and vivid, but it doesn’t mention what I think is one of Jon’s outstanding traits. In a quiet, utterly unassuming way, Jon is one of the most persuasive and politically astute people I have ever met. He will not thank me for pointing this out: I think he thinks that if people know, they’ll be on their guard. He doesn’t do a hard sell (at least not to me); he takes the trouble to understand where his interlocutor is coming from and to find common ground with them. And he has patience; he is not dissuaded from a goal by the idea that it might take a while, or that it must be approached indirectly. And he is very reticent about taking credit.

We wrote Jon’s name into the XML spec, in the passage

XML was developed by an XML Working Group … formed under the auspices of the World Wide Web Consortium (W3C) in 1996. It was chaired by Jon Bosak of Sun Microsystems with the active participation of an XML Special Interest Group … also organized by the W3C.

because we wanted to get Jon’s contribution on record and force him to accept credit. Without Tim Bray, or without me, or any of the other members of the editorial review board and working group, the spec would have been different. Without Jon it would not have come to pass.

In memory of a particularly difficult political task undertaken and successfully negotiated, some of Jon’s friends once gave him a gift that I have always thought apposite: a dark gray bomber jacket, embroidered in dark gray (so the embroidery was virtually invisible) with the words “Subtle and devious”.

Hail, xml:Father!

Scenes from a Recommendation 1: Chicago, Cafe des Artistes

Posted on by

[11 February 2008]

The XML spec became a W3C Recommendation ten years ago this week.

Tim Bray has posted some character sketches from the period; Eve Maler has followed suit with some recollections (and an online version of Maler/El Andaloussi! Woo hoo!); this has inspired me to think about doing the same. What follows is the first in (what I hope will be) a series of moments I remember from the creation of XML.

If you look, you can find a lot of stories about the beginning of XML. It surprised me, at first, that they all seem to be different; it surprised me even more to find some told in the first person by people whom I had not suspected of being involved with XML at all. But I shouldn’t have been surprised. Scores or hundreds of people were involved in the development of XML, thousands in its spread and uptake. In some sense, then, XML will have had scores, or hundreds, or thousands of beginnings. Why should I think I know about them all? Questions like “How did X start?” often mean not “How did X start?” but “How did you come to be involved in X?” — or, at least, that’s how we answer them. The beginnings of XML? I don’t know. But I’ll tell you what I do know; I know when I first heard about it.

The second WWW conference was in Chicago, in October 1994. With Bob Goldstein, one of my colleagues at the University of Illinois at Chicago computer center, I had submitted a paper on how the Web would achieve its true potential only once it had SGML awareness (“HTML to the Max”). We had to do it for the conference in Chicago, because the computer center would certainly not have paid for travel to go anywhere else; they weren’t happy at being asked to pay the registration fee, let alone travel.

This was the conference at which I saw SoftQuad Panorama for the first time, but I could not figure out the stylesheet mechanism well enough to use it to deliver my slides; later I did, and used Panorama for slides for years after that.

Sometime during the conference I ran into Jon Bosak, whom I knew from SGML conferences, and Dave Hollander, whom I may have been meeting for the first time. Jon was at Novell, Dave was at HP (where I believe he was in charge of building hp.com), and the conference hotel (as I remember it, the Hilton on Michigan Avenue it) was hopelessly overcrowded; there was no chance of finding a place to sit and have a cup of coffee.

Fortunately, I was local, and knew the neighborhood slightly, so I led Jon and Dave up the street a bit to the Cafe des Artistes, where we sat on the sidewalk in the October sun and talked about markup and the Web. Browser makers didn’t want to support SGML; they thought it was too complicated and would make the browsers heavy-weight. This seemed like an excuse to me: browsers were already putting on more weight than SGML support would have required. We speculated about defining a simpler profile of SGML, so they couldn’t use complexity as an excuse. Where? The ISO working group was not going much of anywhere with the five-year review and revision of the spec; it seemed unlikely anyone would get any joy there. SGML Open? Somewhere else? Jon had an idea it might fly as an idea for a working group at the new World Wide Web Consortium. Dave thought that SGML support would be the best thing, but if we couldn’t persuade people to do that, he had a fallback idea. HTML appeared hopelessly unequal to the task of publishing serious technical documentation, but Dave’s experience developing the Semantic Delivery Language (SDL) had persuaded him that you could have a reasonably small markup language with some hooks for richer semantics. SDL had been developed for help systems and delivery on CD-ROMs, and in it each element carried an attribute that said what kind of element it had come from in the SGML vocabulary in which the document had been prepared. (Nowadays you’d do that with the HTML class element.)

[Googling for “semantic delivery language” just now, I find that about that time Jon put together a proposal for specifying a Hypertext Delivery Language (HDL) based on SDL and optimized for WWW delivery; the copy on the W3C site says it was last modified 1 November 1994, less than a month after the Web conference.]

Other people had specified subsets of SGML before; I had done one myself in 1992 (“Poor-Folks SGML”), and several others were also used as input to the design of XML. And of course I had just given a paper urging that Web software start supporting SGML.

But I think of that cup of coffee at the Cafe des Artistes on Michigan Avenue as the first time I heard anyone talking about the specific idea that became XML.

And you, dear reader? What are your recollections of the beginnings of XML? When did you start thinking about the ideas that became XML? When did you first encounter the effort that in the end produced the spec? Tell me here, or write about it on your own blog.

Tim Bray on XML People

Posted on by

To mark the tenth anniversary of the XML Recommendation, Tim Bray has resurrected an account he wrote ten years ago of various people involved in the pre-history and creation of XML.

Well worth reading, whether you were there and are looking for an excuse to spend half an hour on nostalgia, or you weren’t there and wonder what it was like. Of course, there is no single “what it was like”: it was like different things from different vantage points. My memories of the initial development of XML are a lot longer on technical discussions and a lot shorter on memorable dinners with movers and shakers.

Devil ain’t got no place to play ’round here

Posted on by

[8 February 2008]

Idle hands, they say, are the Devil’s playground.

Poor Devil. No playground around here these days.

After the XML Schema working group buckled down at our face to face meeting week before last, and worked through all of the Last-Call issues raised against the Structures spec, the WG took a week without a meeting, to allow the editors time to get some proposals done. My co-editor Sandy Gao, whose name will someday be in reference books as a cross reference from “Stakhanovite”, produced wording proposals to close 42 open issues against Structures. In the same time, I managed a proposal to resolve one Structures issue. (Or rather, to resolve it in part.) On the Datatypes side, we didn’t manage quite such a glorious record, but we did manage proposals for eleven issues.

OK, yes, sure, many of the issues we had proposals for were simple to fix: typos, small tweaks to wording, and so on. That’s one of the reasons for doing triage: to have a list of easy items and low-hanging fruit. But still, that’s a lotta issues to close. Drafting and reviewing other editors’ drafts occupied most of my time last week, and this week most of my Schema time went to the mechanical task of just getting the proposals shipped to the working group.

I could have made lots of klog entries, but they would all have read

  • 2008-01-30: finished draft for bug 2947.
  • 2008-01-30: finished draft for bug 3265.
  • 2008-01-30: finished draft for bug 3256.
  • 2008-01-30: finished draft for bug 4839.
  • 2008-01-30: finished draft for bug 4089.

Today the working group adopted almost all of the proposals; they bounced one back and accepted the wording for one issue as a “partial” resolution, with the request that the editors try to revise it one more time, to get it a little better before we close the issue entirely. But we closed a lot of them.

So since this morning’s WG call, I have been generating new copies of the status-quo documents and updating Bugzilla records.

This is not purely mechanical work, but it’s mechanical enough that I’ve had time to think, now and then, while waiting for the server, about the significance of the two tasks.

Keeping a document that shows the current status quo

One of the best decisions I made when I began to work as an editor on XSD 1.1 was the decision to attempt, always, to ensure that decisions made by the WG during a telcon were reflected before the next WG meeting — and preferably before close of business that same day — in a copy of the spec kept in a stable location. This has turned out, I think, to be a useful technique.

I didn’t always feel this way. In 1997 it irritated me profoundly that Dan Connolly used to complain whenever there were decisions the XML working group had made that he didn’t see reflected in the most recent draft of the XML spec he could find. But while I’m still not sure I think his reasons were sound, I have come to believe that his conclusion was correct. (Maybe I didn’t understand his reasons propertly.)

  • It makes it easier for WG members to see where we are.

It makes it easier for other WGs, too, although other WGs seem unaccountably leery of looking at the current status quo document instead of at public working drafts on the /TR page. I suppose they feel justifiably that there can be such a thing as Too Much Information.

  • It means that WG decisions have visible effects immediately (or, as immediately as is compatible with my having to regenerate the spec and check in the new copies, when tends to take a few hours), which is good for morale.

I at least find it alienating and depressing to work hard making decisions in a WG and find, months later, that the editors have still not gotten around to making the text of the spec reflect those decisions. Experience also shows that if much time elapses between decision and revision of the spec, the editors end up forgetting what the WG decided, or conveniently rewriting it in their memory.

  • Constant re-publication (even if it’s only in the member-only portion of the site) also helps keep the document production system in good trim. Problems get found and fixed sooner, and debugging is simpler: fewer problems around means it’s less likely that one problem will be interacting with or masking another.
  • Constant re-publication (even if it’s only in the member-only portion of the site) also helps keep the document in good trim. If I link-check and validate the status quo regularly, publishing a working draft becomes a simple task instead of requiring herculean efforts to fix HTML- and link-validity errors.

We haven’t always managed to achieve the same-day goal; sometimes the spec gets a week, or two weeks, out of date. And on a couple of occasions when outside circumstances were unfavorable, the Structures spec got as much as four months out of date. Bringing the status-quo documents up to date after that kind of interval was a nightmare — a suitable punishment, perhaps, for letting them get so far out of date in the first place.

Bugzilla as issue tracking system

Keeping the issues list up to date has many of the same advantages, although as a WG we have not been nearly so good about that as about keeping the ‘current editors’ copy’ of the spec up to date. And of course, like many working groups we have trouble providing quick response. Most of the bugs we fixed today were reported months ago, some, well, longer ago than that. We need to do better about that; it would help keep the number of issues from climbing so high in the first place.

And if being slow to get back to the reader has a bad effect on the WG’s relation to the wider community, being slow to update the status of issues, once the WG acts on them, has an even worse effect on the WG’s relation with itself. When the issues list is out of date, you can’t look at any issue without the risk that you’re wasting time re-considering something the WG actually already decided once. Or, just as likely, you risk the WG saying “Wait, we don’t need to look at this one, we did it a few months ago” when what they remember is that it was discussed a few months ago, without remembering that it was not resolved a few months ago.

So I have come to believe it’s very helpful to get the issues list updated right away after a meeting. Or preferably during the meeting, but the XML Schema WG has never quite assimilated that idea.

For a long time, we maintained our issues list in XML, using a series of ad hoc vocabularies. Because they were in XML, it was possible to do a lot of nifty things with them; we had stylesheets to indicate status via foreground and background color, we had a good fit between the data and the information we want to maintain about issues, and so on.

But maintaining the issues list in an XML document on the server meant that only WG members with CVS access could update it. And keeping the list in a single XML document meant, in practice, that only one person at a time could (or maybe I mean would) do so. And that person invariably became a bottleneck.

Bugzilla is not well suited to the task of of issue tracking for a working group developing a spec. It’s designed for tracking software bugs, not design issues or spec defect reports; its workflow doesn’t match what any of my WGs does; its terminology is sub-optimal; its notion of text has all the power and charm of ASCII email (which is particularly grating for WGs working with XML technology: we know how much better things can be with good markup!).

But it’s got a convenient Web interface and more than one WG member can be updating things at a time. And I have come to believe that those two facts trump all others. Someday I’ll get around to designing and implementing an XML-based issue tracking system for working groups; it will have a Web interface and suitable markup, and it will be fun to develop.

In the meantime, we use Bugzilla.

So it was with Bugzilla that I spent most of my afternoon, while make and XSLT and CVS checkins went on in the background.

Marking an issue resolved can take time. Since the status-quo version of the spec is not publicly accessible, whenever the comment came from someone outside the WG who doesn’t have member access to the W3C site it’s necessary to transcribe the wording we finally adopted into the bug record, so the originator of the comment actually has a way to tell whether we got it fixed or not. And if the bug applies both to XSD 1.0 and to XSD 1.1, our decision today resolves it only for the latter, so a new issue needs to be raised for 1.0, otherwise we’ll lose track of it.

Two pieces of advice, then, for those using Bugzilla to maintain issues lists:

  • Learn to use the “Change several bugs at once” feature.
  • Learn to use the “Clone this bug” feature.

Enough said.

There’s a final reason that marking issues resolved can be slow going. Because these are Last-Call comments, the working group is responsible for keeping an audit trail to show that all comments have been dealt with, and to document that each person who raised an issue has been asked explicitly whether the WG’s action on the issue has satisfied their concerns.

If they’re not satisfied, the director of the consortium reviews the question when the time comes to move the spec forward. Woe then to the working group who didn’t make an effort to satisfy those who commented on its drafts. If the chair, or the staff contact, can explain plausibly what point is at issue and what the WG has done to try to accommodate the reader who raised the issue and why it’s not possible to do anything more to resolve the comment without breaking something more important, then the director may well sustain the WG in its decision. I’ve seen that happen.

But when the working group did not in fact try very hard to resolve the comment, and all you have to say is “well, we didn’t want to do that”, or “no, we didn’t want to consider that”, then you’re in for a long afternoon of sharp, skeptical questions and there’s a real possibility that the spec will be sent back to the working group so that more time can be spent resolving the open points of dispute. I’ve seen that happen, too.

It’s hard for some WGs to remember, but the goal is not to achieve consensus within the working group. The goal is to achieve consensus within the Web community as a whole.

And that, in the end, is what the whole exercise is about.