The WHATWG Blog

This Week in HTML 5 – Episode 12

Tuesday, November 11th, 2008

Welcome back to "This Week in HTML 5," where I'll try to summarize the major activity in the ongoing standards process in the WHATWG and W3C HTML Working Group. The primary editor was traveling this week, so there are very few spec changes to discuss. Instead, I'd like to try something a little different.

It has been suggested (1, 2, 3, &c.) that HTML 5 is trying to bite off more than it can metaphorically chew. It is true that it is a large specification, and it might benefit from being split into several pieces. But it is not true that it includes everything but the kitchen sink.

For example, HTML 5 will not

• deprecate <textarea>
• allow arbitrary markup in <option>
• include an <altinput> element (reference)
• allow authors to localize the "Browse" button that represents a file input control
• allow authors to localize the open-file dialog that opens in response to activating a file input control
• mandate that browsers display a progress bar during file upload
• limit the number of selected checkboxes or options in a web form
• allow web authors to specify a regular expression constraint on a <textarea>
• support form controls associated with more than one form
• change the default type of <button>
• allow web authors to mark form fields as auto-tabbing
• support form seeding
• rename the HTMLCollection .length attribute to .count
• expose a native JSON parser for web content
• support client-side includes
• try to compete with Docbook

Daniel Schattenkirchner asked whether Almost-Standards mode is still needed. Almost-Standards mode is a form of DOCTYPE sniffing invented by Mozilla in 2002 to address line heights in table cells containing images. Bug 153032 implemented the new mode, which Mozilla called "Almost Standards mode" and HTML 5 calls "limited quirks mode." Henri Sivonen made the point that it would probably be too expensive to get rid of the mode. Like it or not, we're probably stuck with it.

And finally, a gem that I missed when it was first discussed: back in July, "Lars" provided the best documentation of the <keygen> element, ever.

Tune in next week for another exciting episode of "This Week in HTML 5."

Posted in Weekly Review | 3 Comments »

HTML vs. XHTML

Wednesday, November 15th, 2006

One of the predominate issues raised in the recent call for comments was surrounding the whole HTML vs. XHTML debate, with many people suggesting that we should not be extending HTML, but rather focussing on XHTML only.

However, what many people have failed to realise is that HTML5 resolves this issue: The (X)HTML5 specification is in fact specifying extensions to both HTML and XHTML simultaneously, and the choice of using either is no longer dependent upon the DOCTYPE.

Many authors use an XHTML 1.0 DOCTYPE and then proceed to claim they’re using XHTML, but browsers make the decision whether to treat a document as HTML or XHTML based on the MIME type. (X)HTML5 endorses dispatching on MIME type: If the document is served as text/html, it gets parsed as HTML; but if it is served with an XML MIME type, like application/xml or application/xhtml+xml, it gets parsed as XHTML.

Document Serializations

HTML5 introduces the concept of serialisations for an HTML document. A serialisation in this context refers to the physical representation of the essence of the document—the document tree. (X)HTML5 requires user agents that support scripting to expose the document tree to the script using the DOM API and data model. HTML5 uses the HTML serialisation and XHTML5 uses the XML serialisation. Because of this, the distinction between an HTML and XHTML document is reduced.

In most cases, either serialisation can be used to represent exactly the same document. The main differences are that the HTML serialisation, due to backwards-compatibility reasons cannot represent structured inline-level elements (e.g. <ol>, <ul>, etc.) as children of the <p> element and the XML serialization cannot represent all possible document trees that may be created as a result of error recovery in the HTML parsing algorithm. Also, in browsers, some scripting API features and CSS layout details work differently depending on the serialisation of the document due to backwards compatibility considerations.

The XML serialisation used by XHTML must be a well-formed XML 1.0 document. However, unlike previous versions of HTML, the HTML serialisation is no longer considered an application of SGML, but instead defines its own syntax. While the syntax is inspired by SGML, it is being defined in a way that more closely resembles the way browsers actually handle HTML in the real world, particularly in regards to error handling.

The HTML5 serialisation and the accompanying parsing algorithm are needed for three reasons:

1. The browser that currently holds the majority market share doesn’t support XHTML (that is actually served and processed as XHTML).
2. The legacy text/html content out there needs a well-defined parsing algorithm—something that SGML-based HTML specifications haven’t been able to provide.
3. There are content management systems, Web applications and workflows that are not based on XML tools and cannot produce well-formed output reliably. These systems can benefit from new features even though they wouldn’t work reliably with the XHTML serialisation.

On the other hand, thanks to the HTML/XHTML duality, new systems can be built on solid off-the-shelf XML tools internally and convert to and from the HTML5 serialisation at input/output boundaries. Once the installed base of browsers supports application/xhtml+xml properly, these systems can swap the output serialiser and start using XHTML-only features such as lists inside paragraphs.

The New DOCTYPE

In practice, the DOCTYPE serves two purposes: DTD based validation and (for HTML only) DOCTYPE sniffing. Since HTML is no longer considered an application of SGML and because there are many limitations with DTD based validation, there will not be any official DTDs for (X)HTML5.

As a result, in the HTML serialisation, the only purpose for even having a DOCTYPE is to trigger standards mode in browsers. Thus, because it doesn’t need to refer to a DTD at all, the DOCTYPE is simply this:

<!DOCTYPE html>

I’m sure you would agree that that is about as simple and easy to remember as possible. But, for XHTML, it’s even simpler. There isn’t one! Since browsers have not (and will not) introduce DOCTYPE sniffing for XML, there is little need for a DOCTYPE.

However, I should point out that there is one other minor practical issue with DTDlessness in XML. Entity references which are declared in the XHTML 1.0 DTD will not be able to be used. However, since browsers don't use validating parsers and do not read DTDs from the network anyway, the use of entity references is not recommended. Instead, it is recommended to use character references or a good character encoding (UTF-8) that supports the characters natively.

Conformance Checking

You’re no doubt wondering, if there are no DTDs, how will one go about validating their markup. Well, that’s simple. There are in fact other, more robust methods available for checking document conformance. There are several different schema languages that can be used, including RELAX NG and Schematron. However, even they cannot fully express the machine-checkable conformance requirements of (X)HTML5.

Henri Sivonen is in the process of developing a conformance checker for HTML5, which is being designed to report much more useful error messages beyond those that are possible using just a DTD based approach. For example, the table integrity checker discussed previously is one feature that is impossible to implement using DTDs.

Posted in Conformance Checking, Syntax | 6 Comments »