URIs were originally used primarily to identify documents on the Web, or with the use of fragment identifiers, portions of those documents. As Web content has evolved to include Javascript and similar applications that have extensive client-side logic, a need has arisen to use URIs to identify states of such applications, to provide for bookmarking and linking those states, etc. This finding sets out some of the challenges of using URIs to identify application states, and recommends some best practices. A more formal introduction to the Finding and its scope can be found in its abstract.
The W3C TAG would like to thank Ashok Malhotra, who did much of the analysis and editing for this work, and also former TAG member T.V. Raman, who first brought this issue to the TAG's attention, and who wrote earlier drafts on which this finding is based.
]]>The specification has been modified to allow two syntaxes for the time element. You may write time with a T or a single space separator between the date and the time.
<time>2011-12-24T23:59</time>
<time>2011-12-24 23:59</time>
XML documents have a UTF-8 default encoding. Kornel Lesiński asked if it would be possible to do that for documents with an HTML5 doctype. Henri Sivonen (Mozilla), who is also developing the HTML5 parser for Firefox, rejected the suggestion. It would introduce more incompatibilities and more specific behaviors than the already existing explicit mechanisms.
Sometimes Web developers need to extend their content with a richer semantics by adding simple data structure to their markup. A first Working Draft for RDFa Lite 1.1 has been published. For example to specify that this column is written by a human and not a cow.
<p vocab="http://schema.org/"
resource="#karl"
typeof="Person">
This blog post is written by
<span property="name">Karl Dubost</span>.</p>
The purpose of this group is to develop a common specification in OWL for structured and unstructured annotations on Web documents, based on prior work developed by the Annotation Ontology (http://code.google.com/p/annotation-ontology/) and Open Annotation Collaboration (http://www.openannotation.org/) efforts.
You are invited to support the creation of this group: http://www.w3.org/community/groups/proposed#annotation
The WebVTT format (Web Video Text Tracks) is a format intended for marking up external text track resources. WebVTT has escaped HTML5 to be developed by the Web Media Text Tracks Community Group. They also have a twitter account. Anne van Kesteren has created a WebVTT Validator and published the source code on bitbucket. The syntax is a very simple text file.
WEBVTT
00:11.000 --> 00:13.000
<v Roger Bingham>We are in New York City
00:13.000 --> 00:16.000
<v Roger Bingham>We're actually at the Lucern Hotel, just down the street
If humanity had an UndoManager API we might have been able to fix a lot of mistakes. Ryosuke Niwa (webkit) is working on such an API for the Web and he is asking feedback. A long list of use cases has been outlined to better understand what do we need to solve.
Dominique Hazaël-Massieux (W3C) has been giving a summary of the Standards for Web Applications on Mobile. He has published an update for November 2011.
The new methods for append, prepend, … that we mentioned a few weeks ago have been addred to the DOM 4 specification in the mutation methods section. This triggered a new syntax requirement for WebIDL, which has not yet been completely defined. Anne van Kesteren (Opera) has also started to define Mutation observers.
An update has been published for CSS Image Values and Replaced Content and a new editor draft for CSS3 Grid Layout. As a kind reminder, these are drafts and then not stable. If the implementations change them or drop these features, you will have to eat your own hat :)
A tendency in Web development has emerged a little while ago. Web developers started to push hash sign in their URIs not to define an anchor in the document but the state of an application. The W3C Technical Architecture Group has summarized best practices for handling hash signs URIs.
The W3C TAG is working on a few topics in parallel. You could participate constructively to the discussions by subscribing to the www-tag mailing list.
You can now buffer this number, RFC 6455, in your memory lane. The WebSocket Protocol is accepted. Though be careful, because there might still be a bit of breakage depending if your browser has released a version of the implementation but disabled by default. Check your preferences.
In the discussion about extending HTTP status code, Roy Fielding (Adobe) gave an interesting rule for knowing how/when to extend the list of codes.
When extending HTTP status codes, the question that needs to be asked is “how will a client process this response differently than any of the existing status codes?”
This column is written by Karl Dubost, working in the Developer Relations team at Opera Software.
]]>Yehuda Katz and a few others have started a discussion on Restoring PUT and DELETE in HTML5 forms (Issue 1067). The Ruby on Rails Web framework is currently using a hack for simulating PUT and DELETE.
The Web is an amazing big pile of history. border attribute on table elements didn’t have any units. Though people had a tendency to put units such as the wrong <table border="5px">. So browsers repaired automagically to take into account only the beginning of the string and ignore any trailing characters. Sylvain Galineau (Microsoft) raised an issue because he thought it would create issues for microdata values. Ian Hickson mentioned that the incorrect values were not valid but fixed by the browser if wrong.
INS and DEL elements which are used to track insertion and deletion of contents in HTML have a very simple model. So simple that according to Daniel Glazman (Disruptive Innovations), it is not easily implementable in any useful way for authoring tools.
A Community Group has been proposed to discuss ideas around the future of HTML and associated features.
Webkit has a proposed patch for the Network Information API. This is an interesting API because it allows to create apps which behave differently depending if the network is 3g, wifi, etc. For example, imagine a responsive Web design where images of adequate sizes are sent depending on the type of network which gives a good idea of what could be the bandwidth.
Rich Tibbet (Opera) has proposed a model for the Web intents work.
Simon Pieters (Opera) wanted an API to queue a task. After discussing about the opportunity of such a need, Glenn Maynard proposed a piece of code that finally Simon extended.
var queueTask = function(task) {
var mc = new MessageChannel();
var args = [].slice.call(arguments, 1);
mc.port1.onmessage = function(){
this.onmessage = null; task.apply(task, args);
};
mc.port2.postMessage(null);
};
queueTask(function(arg) { console.log(arg, this) }, "test");
Dimitri Glazkov (Chromium team) has proposed a high level overview of Web Components for Web Developers.
The setAttributeNS() is implemented differently in IE, Firefox, Webkit and Opera. The discussion, which started on the mutability of attributes, led to discuss about simplifying the platform for HTML documents by removing the namespacing of attributes. According to Jonas Sicking (Mozilla), that would also improve browser performances. There would still be needed for XMLDocument interface.
When exchanging data in between client and server, there are a few techniques. One of them is XMLHttpRequest which helps inject a data flow into the page without reloading the full context. People often uses it to transfer JSON packaged data. Anne van Kestern (Opera) has added json response type to XMLHttpRequest.
When a client and server interact on the Web, the server answer to client requests with 3 number codes. These have very specific meanings. For example, 200 means that the server has successfully answered the client request. It is happening quite often that Web developers (specifically those developing Web APIs) lack some HTTP status code to have a richer interactions between the client and the server. Mark Nottingham has been working for a while on new HTTP status code.
HTTP/1.1 allows many types of characters. This has a tendency to create security issues when, for example in CGI/1.1, translating these characters into UNIX environment variables. Some of them are not valid and/or parseable characters. Yutaka Oiwa brought the subject on HTTPbis mailing list.
This week, the theme of Anne Van Kesteren’s report about Encoding woes and WebVTT.
This column is written by Karl Dubost, working in the Developer Relations team at Opera Software.
]]>find and findAll methods. The Open Web Platform weekly summary is also mentioning Web architecture, Web Apps WG hosting new work.
The old HTML4 abbr attribute has been deprecated in the HTML5 specification. The role of the attribute was to give a short form of table cells content. It was meant to help users getting the content of these cells quickly. A Firefox patch has just been proposed to implement it.
Frank Olivier (Microsoft) said:
Text editing is certainly a fool’s errand in canvas.
and indeed there was previous attempt to recreate text-editor all in Canvas. Some of these projects have been abandoned since. That said the group is struggling to find solutions for raising accessibility in canvas to an acceptable level. One solution which is being explored is to add primitives for Path.
There are proposals for
The work on Component Models that I mentioned a few times about under the label shadow DOM is moving to the Web Apps WG led by Dimitry Glazkov (Chromium team).
Darin Fischer (Google) proposes to add the Pointer Lock (formerly known as Mouse Lock) spec and the Gamepad spec be added to the Web Applications WG’s charter.
Some fundamental features are missing in JavaScript. I know for example missing things like startsWith and endsWidth on strings annoy me a lot. There is a proposal for evolving ECMAScript on IE blog.
There has been a gigantic thread (with a lot of misunderstandings and rebuttals) about allowing XPath in the find/findAll APIs we were talking about last week. The discussion goes along the common permathread about CSS selectors and XPath has a way to select a path in a DOM. With similar goals, they often addressed different problem spaces and they do not have the exact same set of features. Some people argue it is not worth the cost adding XPath for selecting nodes. Eventually, people will reach an agreement. We are not there yet.
matchesSelector is verbose and people start to look at ways to make it shorter for Web developers. Two proposals have been by Tab Atkins (Google) with .matches() and .is(). Though Dimitri Glazkov said that he wishes to use .is() for components. It would be used like
elt.matches("div span")
Jake Archibald (Lanyrd) is not satisfied with the Shadow DOM and scope stylesheets we mentioned a few times in that column.
Experimenting with new styles for CSS Specifications. CSS shaders is currently having the proposal.
URIs are one of the corner stones of the Web architecture. There is a specification clearly defining the URI syntax and meaning. But as usual with the human Web, things get deployed with errors in a distributed way. What is happening when you get something which looks like an URI but is not really a URI. User agents have for long implemented techniques to cope with the common URI mispellings found on the Web. Mike Smith will start working on a document on how browsers process URIs, following a proposal made at HTML WG F2F during the TPAC 2011. It has been suggested that this should be part of the URL API document.
The Referer HTTP header has been a concern for a long time in terms of security and privacy. Adam Barth is proposing to add a referrer attribute in HTML (meta element) for suppressing its value from each HTTP requests.
This week, the theme of Anne Van Kesteren's report is about XMLHttpRequest.
This column is written by Karl Dubost, working in the Developer Relations team at Opera Software.
]]>An example may be the schema.org example I used in another blog lately:
<div vocab="http://schema.org/" typeof="Product">
<img property="image" src="dell-30in-lcd.jpg" />
<span property="name">Dell UltraSharp 30" LCD Monitor</span>
<div property="aggregateRating" typeof="AggregateRating">
<span property="ratingValue">87</span>
out of <span property="bestRating">100</span>
based on <span property="ratingCount">24</span> user ratings
</div>
<div property="offers" typeof="AggregateOffer">
<span property="lowPrice">$1250</span>
to <span property="highPrice">$1495</span>
from <span property="offerCount">8</span> sellers
</div>
Sellers:
<div property="offers" typeof="Offer" >
<a property="url" href="save-a-lot-monitors.com/dell-30.html">
Save A Lot Monitors - $1250</a>
</div>
<div property="offers" typeof="Offer">
<a property="url" href="jondoe-gadgets.com/dell-30.html">
Jon Doe's Gadgets - $1350</a>
</div>
...
</div>
Running this through the distiller, one gets the following JSON output:
{
"@context": {
"@vocab": "http://schema.org/",
"@coerce": {
"@iri": [
"http://schema.org/image",
"http://schema.org/offers",
"http://schema.org/url",
"http://schema.org/aggregateRating"
]
}
},
"@type": "Product",
"aggregateRating": {
"@type": "AggregateRating",
"ratingCount": "24",
"ratingValue": "87",
"bestRating": "100"
},
"offers": [
{
"@type": "Offer",
"url": "http://www.example.org/save-a-lot-monitors.com/dell-30.html"
},
{
"@type": "AggregateOffer",
"lowPrice": "$1250",
"highPrice": "$1495",
"offerCount": "8"
}
],
"name": "Dell UltraSharp 30\" LCD Monitor",
"image": "http://www.example.org/dell-30in-lcd.jpg"
}
Of course, the generated JSON may be a bit more complex, e.g., if the original page contains other RDFa attributes generating other triples. But it still looks pretty readable to me…
]]>Tidy, the useful piece of code that was helping you to fix your broken XHTML and HTML had not evolved. Björn Hörhmann published a patch to fix it. Dominique Hazaël-Massieux (W3C) decided to create a HTML5 tidy github project
There are many ways of storing information on the Web on the client side. The cookies was one of the first one, but since AppCache and Web Storage have been developed. There is a wiki page on client side database solutions documenting what are the relations between the different technologies.
There is a lot of work going on for enabling a FullScreen API.
I mentioned Web Intents last week. An introduction about Web Intents has been written by the priceless timeless.
There is a proposal for a new findAll property. Jonas Sicking (Mozilla) is asking what type findAll should return.
Anne van Kesteren (Opera) had opened a bug on Webkit bug reporting system about the deprecated document.width and document.height properties. It is fixed! The two properties have been removed from the Webkit source code. He also started a new round of discussions on how to improve the DOM
Rafael Weinstein (Chromium Team) is proposing to have a fragment of DOM being inactive but inside the page for future use. Dynamic web pages could use them during the user interaction later on. The proposal is a declarative Inert DOM (a <template> element)
Fantasai (Mozilla) is explaining how the CSS Working Group is working.
scoped stylesheets have been introduced to define a mechanism where the stylesheet would apply only in a precise context. scoped is more complicated to implement than initially thought.
RDFa is the swiss army knife for injecting rich data into your Web pages. Initially designed for XHTML, the group is in the process of evolving it for HTML. There is a lot of discussion around it on how to make it easy for developers and compatible with the current Web. Sebastian Heath proposed to change a bit the consumption of RDFa to take into account id. Now a Web author needs to declare an about attribute:
<p id="item1" typeof="ex:item" about="#item1">
<span property="item_name">An interesting item (1)</span>
</p>
His proposal is to reduce it to:
<p id="item1" typeof="ex:item">
<span property="rdfs:label">An interesting item (1)</span>
</p>
which would produced the triples of information.
<http://example.org/document1#item1> rdf:type <http://example.org/ns/item> .
<http://example.org/document1#item1> rdfs:label "An interesting item (1)" .
There are at a regular pace discussions about vendor extensions in CSS. In my daily job, I have to contact Web sites which have improper use of CSS and makes it hard to have a good Web experience for any users. So I have written a mail to explain why I disliked them: CSS vendor extension issues. Henri Sivonen (Mozilla) extended the discussion in a more general discussions on how Vendor Prefixes Are Hurting the Web. Daniel Glazman (CSS WG co-chair) doesn’t completely agree, or maybe he does, for certain parts and decided to write an answer to Henri Sivonen, which triggered another supportive post by Alex Russel (Google) on why Vendor Prefixes Are A Rousing Success.
Conclusion? The discussion is going on.
I had missed that last July, but it seems that there is a “new” quaterly publication about SVG. The first issue has 3 articles covering DOM Helper, D3.js and sensorial expressions and emotion.
Henri Sivonen (Mozilla) landed support for HTML parsing in XMLHttpRequest in Firefox engine (Gecko). He is giving details on how he has implemented it. His implementations create a direct feedback for changing XMLHttpRequest specification. The same way Julian Reschke has implemented and tested a part of the specification about content-type rewriting. These are two of the many ways you can help specifications development.
<audio> Soundspubdate attribute.This week, the theme of Anne van Kesteren’s report is about <time> and findAll. I feel there is fatigue desire to know if it's useful in Anne’s report. He is asking for feedback.
This column is written by Karl Dubost, working in the Developer Relations team at Opera Software.
]]>hgroup and time elements, lang attribute. There are discussions on starting work on Web Intents and how to create a simpler DOM for documents fragments. Plenty of other things. Enjoy.
The hgroup element, which was proposed for defining sub headlines, is still being actively discussed. It is not yet clear if it should be replaced by a different element with a simpler content model, by an attribute, just dropped or maintained.
The lang attribute helps authors to specify the language of the content in an HTML page. Some people consider that the lang attribute validation constraints are not sufficient.
Tantek Çelik (Mozilla) is proposing refinements for the time element, which has just been added again to W3C HTML5 Editor draft.
Bryan Sullivan (AT&T) is writing a “Push API” that would use the Server-Sent Events specification. That becomes handy in situation of low consumption on mobile handsets by offloading management of EventSource connections. The event delivery can be handled by other types of push servers.
The WebApps and Device APIs WGs are joining forces around Web Intents proposal, the new cool kid in town. The aim is to reinvent a kind of Web RPC. Basically Web applications should be able to register themselves so you can hook them to specific services. For example if you want to trigger a specific Web applications for managing mailto: links.
AppCache is a technology which was created for enabling the possibility for an application to run offline. After having been deployed for a while, Web developers have noticed a lot of issues in the way it was initially built. A community group has been created for Fixing Application Cache. Join!
Yehuda Katz would like to be able to take a string of HTML and parse it into a document fragment without knowing the context in advance.
var frag = document.createDocumentFragment();
frag.innerHTML = "<tr><td>hello</td></tr>"
someTable.appendChild(frag)
João Eiras (Opera) agrees but proposes a different code.
Ojan Vafai (Chromium Team) proposed to create new methods for the DOM instead of hacking around the old ones.
lets add the following methods to Node:
prepend(nodeish) – Adds to the start of the node. append(nodeish) – Adds to the end of the node. before(nodeish) – Adds before the node. after(nodeish) – Adds after the node. replace(nodeish) – Replaces the node. remove() – Removes the node.
Anne van Kesteren (Opera) described the new DOM methods and their model. It’s not yet stabilized. Read the full thread.
If you remember I talked already a few times about mutation events. The work is still in progress. So much that the initial musings on them has been scraped. The specification contains currently a placeholder on how Mutation Events are implemented in Chrome and being implemented in Mozilla but this is likely to change again.
The W3C Technical Architecture Group has started a discussion about the experimental Google Protocol SPDY and its interactions with Web Architecture. The latency in HTTP communications is an issue that Web developers and browser implementers are trying to tackle. In an era of applications being on the Web, the hunt to anything slowing down the responsiveness is important. Google worked on a proposal for modifying the way the client and the server communicates. This has strong consequences for the Web architecture, among others caching.
You love moving blocks around? Yes but which syntax in which language? An effort, currently only an editor draft, is going on to merge SVG/CSS/2D/3D transforms specifications as a unique transform specification.
X-Forwarded-For: is currently the way that some proxies indicates that the HTTP request they are handling is coming from another IP. A. Petersson, M. Nilsson are writing an IETF RFC draft for defining Forwarded-For HTTP header. For example, clients with an ip1 (such as Opera Mini or Amazon Silk) are using a proxy client (with an ip2) for creating the HTTP requests. The proxy will send to the requested server, the following information.
X-Forwarded-For: ip1
You know it already: Cool URIs do not change. It means that you should be able to maintain your URIs space for a very long time so people can rely on them when interacting on the Web. You could even create a URI persistence policy for your company or organization. The W3C and the Digital Curation Centre are organizing a workshop on Domain names and persistence on December 8, 2011, in Bristol (UK).
This week, the theme of Anne Van Kesteren’s report is mainly about TPAC 2011.
This column is written by Karl Dubost, working in the Developer Relations team at Opera Software.
]]>As also announced in my blog in May, I have also made an accompanying service called the (RDFa) validator. It relies on the same code as the distiller, except that it catches the possible error and warning triples and makes a human-readable version of those. Note that the validator can also be instructed to check RDFa 1.1 Lite, ie, it issues warning if the RDFa content uses RDFa attributes that are not part of RDFa 1.1 Lite.
The usual caveat applies, of course: this is still a service under development; it may change as the specification of RDFa evolves and, obviously, if contains bugs that I do not know about…
]]>This work opens up new possibilities also for developers who intend to work with schema.org data using RDF-based tools and Linked Data, and defines a simplified publisher-friendly 'Lite' view of RDFa.
However, one has to be careful about a detail: the RDFa 1.1
version that will be processed is not
the latest “official” W3C draft; indeed, as a result of feedback’s and technical
discussion, the next release of RDFa 1.1 will include some
significant changes. As Dan emphasized in his blog, there are
still some technical details to finalize before the Working Group
would publish that new draft, but the changed version is already
available as an editors’ draft. The most important new feature, as far as the
Schema.org examples also go, is the changed behavior of the @property
attribute: in the overwhelming percentage of RDFa usage, it
becomes synonymous to @rel. (What essentially
happens is that, in the presence of, say, an @href
attribute, the value of that attribute is bound to @property
instead of a possible literal.)
The Schema.org datamodel page has an early example showing some canonical Schema.org use cases in terms of RDFa 1.1. It encodes an earlier version of the example given on the Schema.org Product. Here is how the same example looks like in the new setting, i.e., RDFa 1.1. This example is also in RDFa 1.1 Lite, i.e., the simpler albeit strict subset of RDFa 1.1:
<div vocab="http://schema.org/" typeof="Product">
<img property="image" src="dell-30in-lcd.jpg" />
<span property="name">Dell UltraSharp 30" LCD Monitor</span>
<div property="aggregateRating" typeof="AggregateRating">
<span property="ratingValue">87</span>
out of <span property="bestRating">100</span>
based on <span property="ratingCount">24</span> user ratings
</div>
<div property="offers" typeof="AggregateOffer">
<span property="lowPrice">$1250</span>
to <span property="highPrice">$1495</span>
from <span property="offerCount">8</span> sellers
</div>
Sellers:
<div property="offers" typeof="Offer" >
<a property="url" href="save-a-lot-monitors.com/dell-30.html">
Save A Lot Monitors - $1250</a>
</div>
<div property="offers" typeof="http://schema.org/Offer">
<a property="url" href="jondoe-gadgets.com/dell-30.html">
Jon Doe's Gadgets - $1350</a>
</div>
...
</div>
This is clearly significantly simpler than the previous version. Indeed, the compelling reasons for the changes in RDFa 1.1 (compared to its previous versions) was to achieve that simplicity.
If you are interested in some of the technical details… Some of the notable differences, compared to the previous versions of RDFa 1.1 (and also shown on that example) are:
@property has become richer. For
example, when used on the <img>
element, it results in a triple with an IRI reference as a
subject, rather than a literal. This was (and still is!) the
behavior of @rel but, in this case, @property
can also be used with a similar result. (That is also the reason why @rel is not used in RDFa 1.1 Lite any more.)@property and @typeof
has also changed. @typeof generates a new blank
node (@property
(again, instead of generating a literal). One could consider
this combination as a shorthand for an extra @resource or @href
attribute using a (new) blank node identifier. @property and @typeof:
the generated blank node “chains”, i.e., is used as a subject
for subsequent triples in the sub-tree. This makes a very
frequent idiom (repeated several times in the example) simpler
than before. For reference, a portion of the generated RDF is as follows:
@prefix schema: <http://schema.org> .
[ a schema:Product ;
schema:image <dell-30in-lcd.jpg> ;
schema:name "Dell UltraSharp 30" LCD Monitor ;
schema:aggregateRating [
a schema:AggregateRating ;
schema:ratingValue "87" ;
schema:bestRating "100" ;
schema:ratingCount "24"
] ;
schema:offers [
a schema:AggregateOffer ;
schema:lowPrice "$1250" ;
schema:highPrice "$1495" ;
schema:offerCount "8"
] ;
schema:offers [
a schema:Offer ;
schema:url <save-a-lot-monitors.com/dell-30.html>
] ;
...
]
]]>
There are a lot of things to say about the fruitful meetings we had during this week. Maybe another time.
The time element was dropped from the specification, but the community requested to be restored.
There is yet another difficult discussion on extensibility and how to handle it properly. Time to time, this topic will happen. This time, it is related to specifying arbitrary attributes for Audio-Video.
The hgroup element is not satisfying. Kornel Lesiński is proposing to replace it with the hsub element with a simpler content model.
(Do not copy that code in your pages.)
<body>
<h1>Title</h1>
<hsub>Subtitle</hsub>
<h1>Second Title</h1>
<div>
<hsub>Second Subtitle 1</hsub>
<hsub>Second Subtitle 2</hsub>
</div>
</body>
<article>
<hsub>The Magical</hsub>
<h1>Title</h1>
<hsub>That Has</hsub>
<hsub>Multiple Subtitles</hsub>
</article>
When developping offline applications, we are using a manifest file containing the file to cache. There is a proposal to add syntax to the manifest that would to allow always request files when online, but not when offline. There is also a proposal to be less dependent on the URL and have an additional identifier to cope with minted URLs which tries to avoid caching (which IMHO is circular).
one feature Web developers are asking for is the ability to draw DOM objects to an HTML canvas. — Robert O'Callahan, Mozilla — Drawing DOM Content To Canvas
There is a discussion brought to the HTML WG by the WebTV task force to know if there is a possibility to add a mechanism to protect content. There is no resolution yet. On this same topic, an interesting article has been published on the history of the different systems proposed in the past.
There are more than a few reasons digital rights management (DRM) has been largely unsuccessful. But the easiest way to explain to a consumer why DRM doesn’t work is to put it in terms he understands: “What happens to the music you paid for if that company changes its mind?” It was one thing when it was a theoretical question. Now it’s a historical one. — The DRM graveyard: A brief history of digital rights management in music
A new draft has been published by James Snell for Prefer Header for HTTP. The Prefer request-header is used to indicate that particular server behaviors are preferred by the user-agent, but not required for successful completion of the request.
The version 17 of HTTPbis drafts has been published too.
This week, the theme of Anne Van Kesteren’s report is mainly about <time> and <data>.
This column is written by Karl Dubost, working in the Developer Relations team at Opera Software.
]]>W3C's Math working group maintains a page with information about the various ways to put math on the Web and this article is only about one aspect: configuring an Apache server to serve XHTML. That won't help people with older user agents to see the math, but it is necessary for newer software.
Until HTML version 5 is ready, the only way to put math in HTML is to use XHTML instead. But not all user agents accept XHTML. Which gives us at least three choices: offer them the XHTML file anyway (they might not be able to do anything more with it than save it to disk), give them an alternative without math instead (the best solution, but it requires writing a second file), or give them the same file and pretend it is HTML. That last solution isn't very nice: we're serving invalid HTML to those clients. But the XHTML specification has some guidelines for how to limit the damage with a reasonable chance that the result is readable. The math won't show correctly, but everything else probably will. So that is the solution we assume in this article.
Aside: Some browsers don't distinguish HTML and XHTML. They assume that an author who used a <math> tag in HTML just forgot to use XHTML (or is trying to use HTML5 already). But Opera (the current version is 11) is an example of a browser that does not do that. It only treats a document as XHTML if you say that it is XHTML. Which is probably the better approach. At least it complies with the standards.
User agents send a so-called Accept header in each request to a Web server with the list of formats they understand. Each format is identified by its Internet Media Type. The list typically includes things like PNG (“image/png”), JPEG (“image/jpeg”) and, of course, HTML (“text/html”). User Agents often also indicate which formats they prefer over others, but we'll ignore that here, for simplicity. Specifically, we'll check the list for XHTML (“application/xhtml+xml”).
Microsoft's Internet Explorer version 8 is an example of a client that does not accept XHTML, unless the browser has been extended with a plug-in that handles such files, such as MathPlayer.
To summarize: If a request to our Web server indicates that the client accepts XHTML, we'll respond with our XHTML file and label it correctly, i.e., as application/xhtml+xml; if not, we'll send the XHTML file anyway, but tell the client that it is HTML, i.e., text/html.
Different Web servers have different ways to make that happen. Here is a recipe for the Apache server. It relies on Apache's mod_rewrite module. That is an optional module, so make sure that it is enabled. (It usually is.)
We're assuming that our XHTML files have names that end in the extension “.xhtml”. If the extension is different, you'll have to modify the first and third lines in the code below.
In the same directory as those files, we create a file called “.htaccess” with the following content. (If the file already exist, you'll have to find some way to integrate these lines with what is already there. You may need to read the Apache documentation…)
AddType application/xhtml+xml .xhtml
RewriteEngine on
RewriteCond %{REQUEST_FILENAME} \.xhtml$
RewriteCond %{HTTP_ACCEPT} !application/xhtml\+xml
RewriteRule .* - [type=text/html]
It may be necessary to add a RewriteBase directive as well, depending on how the Web server is set up. If in doubt, add
RewriteBase /path/to/my/files
where “/path/to/my/files” is the part of the URL after the name of the server and before the actual file name. (With a slash at the start and not at the end.)
The first line above tells the Apache server that all files ending in “.xhtml” are XHTML files. The other lines define the exception: when the name of the file that was requested ends in “.xhtml” and the client does not accept “application/xhtml+xml”, we return the file with a media type of “text/html” instead. Note that the “!” on the fourth lines means “not.”
For an example of this recipe in action, try the Math on the Web page. With most recent browsers, the three examples in the middle of the page will show up as actual mathematical formulas. User agents that do not understand the math will show just a string of letters there, but should still show the rest of the page correctly. If your browser offers something like a “View document information” or “Page information” menu, you can check what type the document has: text/html or application/xhtml+xml.
For a page such as this one, where the correct display of the formulas is desired, but not essential, this is good enough.
And if the degraded display of the math is not good enough? Then you will have to do the extra work and write an HTML version with the math replaced by something else: images (such as made with the already mentioned LaTeX2HTML), some JavaScript to simulate math with HTML (such as MathJax), or a textual description of the formulas. The choice depends on the Web clients you want the HTML to be used by.
No need for the “Rewrite…” rules in that case. Just give the XHTML version the file extension “.xhtml” and the HTML one “.html” and let Apache do the rest.
]]>
You have to swipe reasonably quickly. If you want to scroll the viewport, drag your finger slowly across the screen in the direction you want to scroll. Of course, this all depends on how much content people cram into their slides. You should be able to use the native pinch/stretch gestures to change the zoom factor. There is further work to do, e.g. on device detection and on expanding the size of the table of contents. However, I very much look forward to your feedback and suggestions for improvements. ]]>
Structured data is picking up in the search world. The example that took the headlines in the blogosphere (and beyond) this summer: schema.org, jointly initiated by Google, Microsoft, and Yahoo! On 21 September, the three initiators of schema.org co-organized a workshop held on the Microsoft Campus in Mountain View.
Since the original announcement of schema.org in June this year there has been quite a lot of discussions on the blogosphere and elsewhere on the role, importance, and the future of the initiative. There were also lots of miscommunications on all sides, which is rarely helpful. It is important to find the common ground in a community, which, after all, has the general goal of helping the evolution of structured data on the Web. Clearly, the search engines have a major role to play here. The workshop—which gathered around 70-80 people all across the community, including producers of structured data, experts in the field, and representatives from search engines like Baidu or Yandex which don't (yet?) participate in schema.org—was therefore an important step toward building broader buy-in and, eventually, consensus.
The event schedule included presentations, break-out groups on specific technical issues, and a panel. The technical topics focused on two issues: the structure and the role of the schema.org vocabulary, and the syntax to express those in HTML.
Vocabularies. Schema.org, as it stands today, provides a fairly detailed, but high level vocabulary on specific subjects that can be used in an HTML page. Mark-up in that vocabulary can be consumed directly by a dedicated application (like indeed the search engines), or it can be integrated with other data, e.g., by converting the structured data into RDF and using the usual data integration approaches provided by Semantic Web techniques. (Note that schema.org has published, quite some time ago, an OWL version of the vocabulary). The main issue for the future, however, is how this vocabulary will evolve, and how it will relate to other vocabularies on the Web, and how schema.org will relate to other efforts to develop such vocabularies.
At present, the schema.org vocabulary can readily be used in an HTML content mixed with other terms and classes as long as those are identified using full URIs of those (the details depend on the exact syntax). In particular, HTML page using a mix of schema.org and any other terms is accepted by the search engines. The presence of non-schema.org classes or properties does not have any negative side effects. Although this might sound obvious now, it was one of the issues that weren't clear when schema.org was initially announced; this led some to believe that such HTML content would be rejected as invalid. The opposite is the case. At the workshop, Martin Hepp presented practical examples of how schema.org vocabularies can be mixed with outside vocabularies in the case of the GoodRelations ontology.
Schema.org also provides an extension mechanism within its own vocabulary. Existing schema.org URI-s can be extended using a "/" character concatenated with other user-defined strings. While simple, this mechanism raises a number of questions that were discussed at the workshop. For example, how would one find out what that specific new term means (the new URI cannot be dereferenced, as these are still on the schema.org domain)? How would term equivalences be secured? As one of the presenters put it, the current extension mechanism is hardly more than a specialized tagging syntax and we all know the issues around similar but non-identical tags on sites like Delicious or Flickr. One interesting approach that surfaced during the discussion, was that search engines will have crawl data available on these “tags” and, maybe, by publishing those data, some of the widely used extensions may converge into something more stable. Some sort of a crowd-sourced term definition mechanism. The future will tell whether this is a viable option, but it certainly is an interesting direction.
In some cases the schema.org initiative might choose to adopt
vocabularies developed by other communities, and include them into
into the “official” schema.org vocabulary hierarchy. Evan Sandhaus
and Andreas Gebhard told
us about the process that is expected to lead to the
adoption of the rNews
vocabulary by schema.org. (This was officially
announced by IPTC since.) The journey to achieve that was
interesting and did raise some questions, too. For example,
vocabularies are not just simply included; instead, each and every
term had to be discussed with the schema.org owners, possibly
leading to some changes and even exclusions. Issues resulting from
this include general process, public accountability, etc., and
still need to be clarified and possibly developed further.
Additionally, there are questions around the exact names, the URIs
used to identify terms: will there be a term in the rNews name
space (i.e., http://www.iptc.org/ns/1.0/) and a
sibling with a similar role in the schema.org name
space? Will the vocabulary owner publish a separate vocabulary
files containing, for example, owl:equivalentProperty
statements for those terms? While this might not be a problem for
the relatively new rNews (they may decide to simply adopt schema.org
URIs), it is likely to become an issue for more established
vocabularies.
In general, there was an agreement in the room that extensibility of vocabularies is important, and that more work is needed beyond the . While the schema.org vocabulary will play a hugely important role in future, it cannot (and, as the schema.org partners emphasized, does not intend to!) cover all areas of structured data. As announced earlier, the new W3C SWIG Task Force on Web Schemas (led by R.V. Guha, from Google) will become the main discussion forum to discuss those questions.
Syntax. The other major thread of discussion in the past few months was the syntax to be used to include structured data in conjunction with schema.org. Should it be only microdata (as suggested by the schema.org site)? Should it also be based on microformats or on RDFa? All of the above?
In a separate break-out discussion Ben Adida made a presentation
on RDFa 1.1,
showing how this upcoming version of RDFa provides a level of
simplicity that may make it suitable for the purposes of
schema.org, too. The discussion that followed, beyond some
technical issues (e.g., whether RDFa should retain the duality of
using @rel and @property attributes),
concentrated on the more general question whether search engines
should accept multiple syntaxes or whether there should be only
one. After some discussions it was felt that by not
allowing multiple syntaxes a number of long tail applications
could be excluded. Indeed, some applications may need more complex
expressions than what microdata provides today, but those
applications may also want to use schema.org vocabularies for
consumption by search engines. The consensus in the room was that
multiple syntaxes ought to be accepted, although it was also
necessary to look at some technical issues around, for example,
RDFa 1.1 to possibly simplify it and make it (or a subset thereof)
more suitable for average Web authors. The W3C
SWIG Task Force on HTML Data, led by Jeni Tennison, will
play a major role in fleshing out those technical issues. Although
there was no clear commitment (yet?) from the search engines that
RDFa would be accepted
alongside microdata, the feeling was that there is indeed a high
probability that this may happen at some point. The syntax
sessions felt like an important break-through after what had been
a period of contentious discussions.
All in all, it was good day, which may be remembered in future as an important milestone in the evolution of Structured Data on Web sites, and, as a consequence, in the future of the Semantic Web. Thanks to all the organizers, and also to RV Guha, Jeni Tennison, and Dan Brickley for helping to set up the SWIG Task Forces!
]]>The role of the schema.org site is twofold. It defines a family of vocabularies that search engines "understand"; although these vocabularies are still evolving, they reflect the areas that search engines consider as most important for average Web pages. Independent of the vocabularies, schema.org also defines the syntax that search engines understand, i.e., how the vocabularies should be embedded in an HTML page. At the moment the emphasis from schema.org is on the usage of microdata.
As with all such important events, the announcement of the schema.org site has generated lots of discussion on the blogosphere, on different mailing lists, twitter, and so on. The discussion crystallized around two, technically different set of issues:
These issues will be discussed on the upcoming schema.org workshop in Mountain View, CA, on 21 September. They are also within scope of discussion within Semantic Web Interest Group (SWIG). Accordingly, as a result of a variety of discussions, I am proposing two new SWIG Task Forces to discuss these and flesh out solutions. Note that this is also related to a TAG request from June. Assuming the proposals are approved, the two Task Forces will be:
Both Task Forces should be public, both in terms of joining the respective mailing lists or following the discussions via the public archives.
Everybody is welcome!
]]>The I18N Core Working Group has raised an issue about the HTML5 definition of quotes property. The default property should be defined by the language of the text and not by the locale of the browsers.
Tim Berners-Lee explains the architectural decision on why fragment identifiers are not sent to the server when they are deferenced.
Laura Carlson proposed to change example on how the article element is used. In HTML5 examples, the article element contains heading and nav elements. She is proposing to reserve the article for pure content in a way which enable screen readers to jump directly to the content avoiding navigation elements.
Shaun Moss wants to propose a comment element for blog posts. A long discussion started.
Eric Muller (Adobe) has sent to the Unicode Consortium a proposal to develop a Unicode property and algorithm to support Japanese layout. Japanese can be written horizontally or vertically and it is important to be able to determine the orientation of the characters in vertical lines.
HTML5 Forms have client side validation with error messages. The tooltip is browser dependant and varies widely in style. Peter Gasston is proposing to add new properties for styling these form validation messages.
Peter Lins (HP) announced the new CSS Test Suite Management System.
Aryeh Gregor (Google) would like to extend the selection property in the DOM for allowing more than one creating the possibility of buffering, manipulating, deleting them. He also proposed to remove the multiple ranges selection. This property allows to select a piece of text in a Web page and then holding the command key to select another part of the text without having to do two operations. Only Firefox currently implements this feature.
Ryosuke Niwa (Google) needs events that fire before/after user editing action and execCommand take place. He proposed the name beforeEditAction and afterEditAction.
Dominic Cooney (Google, Chromium) wants a way to register new elements not necessary described in the specification. For example, it could work doing something ala
HTMLElement.register('x-contacts', ContactPicker);
The first argument is an element name. The second is a constructor function, whose prototype property points to an object which introduces the API for contacts (eg a refresh method) and is wired up to HTMLElement.prototype.
Anne van Kesteren (Opera) notes that its the backdoor to introduce proprietary markup on the Web. The fallback behavior in absence of scripting is another issue. The discussion is still going on.
Anne van Kesteren (Opera) has removed the entity references from DOM Core (DOM4) and then it modifies the HTML5 specification. Entity references were enabling the creation of markup constructs in the doctype. It introduces a lot of complexities in the management of DOM Nodes.
Kentaro Hara (Google) has requested HashChangeEvent constructor to make all events constructable as well a PageTransitionEvent constructor. It has been integrated right away in HTML5 specification.
Boris Zbarsky (Mozilla) notes that Gecko, WebKit and Presto have three different implementations of window.XMLDocument. There are discussions going on how it should be properly specced still taking into account the differences of implementations across browsers and the interoperability issues on legacy code.
Charles Pritchard (Jumis) needs a baseline property on the TextMetrics object from Canvas 2d. The baseline corresponds to the vertical offset of the anchor point
.
var t = ctx.measureText('text span');
t == { width: int, baseline: int };
David Geary proposes the creation of two new methods in canvas 2D: Path getPath(), which would return a path object representing the context’s current path, and setPath(Path), which would set the current path. That would make it easier to drag objects on a path.
Three Last Call Working Draft documents, Performance Timeline, User Timing, Resource Timing, have been published. The deadline of comments on the first two documents is September 22 and Resource Timing is September 15.
To avoid having to rebuild mime messages from scratch, Charles Pritchard (Jumis) would like to extend FormData object. He is taking example in the Picasa developer guide on posting photos and a code example:
var callback = function(blob) { xhr.send(blob); };
formData.toBlob(callback, 'multipart/form-data');
Julian Reschke () has rewritten the HTTPbis Working Draft to add information about the history of HTTP Redirection (3xx)
Joel Martin wanted to be able to detect if the connection allows for binary data transmission in Websockets. Simon Pieters (Opera) proposed to use the already existing binaryType.
var binarySupported = typeof WebSocket.prototype.binaryType != 'undefined';
It seems that chrome implementation is incomplete creating interoperability issues. It might be fixed in future versions.
This week, the theme of Anne Van Kesteren’s report is Parsing APIs.
This column is written by Karl Dubost, working in the Developer Relations & Tools at Opera Software.
]]>“How to organize a W3C Specification” is a common question at W3C. This time it started about the DOM specifications. The argument falls both on side of the consistency, work style, and technology design. There is no ultimate and definitive answer. In my opinion, you need to choose the format that will maximize participation for your context. The specification organization might be also influenced by the way you want to design the technology.
A new group for the Web Education/Evangelization community has been opened. Chris Mills is the co-chair of the group with Doug Scheppers. People on the mailing-list have started to introduce themselves. Join! It is free.
A while ago, I have talked about the Shadow DOM. The discussion evolved led by Dimitri Glazkov (Google) and Dominic Cooney (Google) into the Component Model, a way to introduce support for creating custom DOM elements enabling layout managers or author UI elements included in the page, but not really part of the page. It inherits from the work done on XBL, XBL2 and MS HTML components, but will be more modular. See also Component Model Update mail and also this one.
Your days of DukeNukem are not over. There is a proposal floating for a Joystick API. With the rise of HTML5 games popularity, there is a growing interest for this proposal.
registerProtocolHandler gives the possibility to Web sites to become handlers for specific protocols. It is currently implemented in Chrome 13. There was a proposal on the list to extend the protocol.
Would it be nice to be able to define how to proceed with undo/redo features but inside the browser? Ryosuke Niwa (Google) has proposed a specification along use cases. Ian Hickson decided to remove the old UndoManager so that people could focus on Ryosuke Niwa’s proposal.
MouseLock is a proposed API to give the possibility to block the mouse in some circumstances. Vincent Scheib (Google) covered some of the issues identified with the proposal.
Digital images contains a lot of hidden metadata such as date, focal length, etc. These are contained in the EXIF part of the image. Some camera includes the orientation of the image when taken. Tab Atkins (Google) is proposing to add a naturalOrientation property to the img element so it could be used in-browser photo-editing tools.
Be careful with the CSS Flexbox (a feature giving you the possibility to reorder the boxes in CSS). This is one of the CSS module which has been quickly implemented by some browsers vendors. Too quickly? Web developers have started to use it and there is already some legacy code online. Why legacy? Flexbox is going through major revisions with backward incompatible changes. Tab Atkins (Google) is working right now on the layout algorithm.
The Web is evolving from a Web of documents to a Web of applications. This creates new constraints and usages to the system. HTML5 created history.pushState() and history.replaceState() for managing the history of a navigation and gives proper and usable URIs. Ashok Malhotra (Oracle) published a new version of a W3C TAG finding on Identifying Application State.
There is a request on allowing @autofocus for any elements having @tabindex property in HTML. This would give the possibility to get a frame like behavior for some blocks in the document. When people create non scrollable section in a Web page, it creates a load of secondary issues.
Channy Yunn has proposed a Web Crypto API Community Group. It has not been accepted yet. If you are interested, join the effort. If you need more information about the topic, see Web Crypto API and DOM Crypto API
Aryeh Gregor (Google) has proposed to extend the DOM for allowing authors to specify modifiers for accesskeys. Right now, it is not possible to reassign the modifier which is dependent on the system (for example, the command on macosx and Ctrl on windows).
When dealing with a document, you might want to change the name of an element in the DOM by another name. Aryeh Gregor (Google) has defined in the editing specification an algorithm for it. The discussion revived an existing feature called renameNode. The current property is still missing features, but there is a will to include it in DOMCore.
This column is written by Karl Dubost, working in the Developer Relations & Tools at Opera Software.
]]>HTML5 is still in Last Call but the last call is finishing on August 3, 2011
Accept: HTTP header specifying a language that the server can’t provide? Mark Nottingham is proposing to send either a default format or a 406.This column is written by Karl Dubost, working in the Developer Relations & Tools at Opera Software.
]]>HTML5 is still in Last Call.
RFC from implementers on Element.innerText by Aryeh Gregor
Björn Höhrmann created a prototype for a framework and a test suite for specifications using Javascript.
The big all W3C Working groups meeting, TPAC 2011, has been opened for registration. The Plenary day is an open session but you have to register. The meeting will be held from October 31 to November 4, 2011 in Santa Clara, California, USA.
A Web site with a list Open Web Platform technologies
A new draft of URI template has been published.
The discussion highlighted last week about SVG, Canvas and accessibility has been going on for the full week, also the discussion about mutation events.
A discussion about test suites and RFC2119 shows the misunderstanding people have in between conformance, technology organization and certification.
A long HTTP discussion on the meaning and implementations of 101 Switching Protocols
A new Exception model has been defined in WebIDL. The consequence is that other specifications might have to change. Anne van Kestern is asking if it’s an issue for the specifications editors.
Last tweaks for getting WebSockets API to Last Call
This column is written by Karl Dubost, working in the Developer Relations & Tools at Opera Software.
]]>HTML5 is still in Last Call.
Maciej Stachowiak (Apple) unsatisfied with the discussion on Shadow DOM API has started a new thread about Component Models and Encapsulation
Anne van Kesteren (Opera) proposed to publish From-Origin as a first public WD but there were a few comments from Brad Hill (eBay) about security, and from Björn Höhrmann
Aaron Colwell (Google) is proposing to extend HTML5 video for adaptive streaming.
Anne van Kesteren (Opera) has proposed to reconcile document.URL and document.documentURI
Call to publish Widget Packaging and XML Configuration as a Proposed Recommendation. You can read the implementation report for 4 products.
The discussion on immediate (Canvas) and retained (SVG) mode graphics is still going on. Kimberly Blessing (Comcast) reminds us that there is a big interest for Canvas from set-top boxes implementers. Some interesting questions about accessibility led Doug Schepers to write Retain Accessibility Immediately. A more focused discussion on solving concrete cases would help. Right now, it is often a meta discussion about accessibility and graphics mode. This ties to discussions such as the Javascript PDF viewer currently in development at Mozilla. Matt May (Adobe) gave a list of Javascript projects using canvas creating accessibility issues.
Mutation events replacement is the other big discussion of the week. First of all, lets’s go back to the DOM Level 2 Event Model specification published in 2000. The specification says: Mutation Events The mutation event module is designed to allow notification of any changes to the structure of a document, including attr and text modifications.
Olli Pettay (Mozilla) mentioned that there was a patch for Gecko implementing a variant of a proposal by Jonas Sicking in 2009. Sergey Ilinsky (Ample SDK implementer) in June 2009 asked for Mutation events use cases. There is another giant thread about Mutation Events on the DOM mailing list that took place in June 2009 and we can find traces in March 2009.
Some servers are unable to deal with empty filename parameter in XHR, Anne Van Kesteren (Opera) added a blob for File objects in this case.
James Kozianski (Google) proposed in the past to add to the registerProtocolHandler specification the two functions: isRegistered() and unregisterProtocolHandler(). Ojab Vafai (Google) is wondering if the proposal makes sense. Timeless disagrees with the benefit of this feature for users. Some people proposed to use the notifications model but there is a balance to maintain in terms of features when it comes to user agreement interacting with Web applications.
Discussion on AppCache. The discussion seems to mix understanding about what is HTTP and AppCache with a bit of user interactions.
Should we have a specific HTTP Status code for HTTP headers which are too big? It raised the question of what is happening in the wild? What the servers and clients do with big HTTP headers?
Mark Nottingham proposed to clarify the 1xx response semantics in HTTP.
This column is written by Karl Dubost, working in the Developer Relations & Tools at Opera Software.
]]>HTML5 is still in Last Call.
This column is written by Karl Dubost, working in the Developer Relations & Tools at Opera Software.
]]>HTML5 is in Last Call. The HTML WG may expect a lot of comments.
203 Non-Authoritative used and should it be deprecated?Gecko, Presto, and Webkit all support on* event attributes on all DOM elements, not just HTMLElement. IE9 seems to only support them on HTMLElement.Boris Zbarsky (Mozilla) proposed to be supported on all DOM elements but element-specific (e.g. “click”).
<style scoped>This column is written by Karl Dubost, working in the Developer Relations & Tools at Opera Software.
]]>HTML5 is the next revision in the core markup language of the Web, and offers powerful tools for creating Web-based applications that will run on any device. It is imperative that HTML5 meet the needs of all Web users, including those with disabilities.
HTML5 includes new features, such as media and Canvas, for which WAI is working to ensure comprehensive accessibility support. WAI is also working to address current gaps in support for other accessibility requirements. Accessibility features missing at the time of the last call publication are listed within the status section of the HTML5 draft. Updated details on the status of gaps in accessibility support are available on the HTML Accessibility Task Force Wiki.
WAI has been working with the HTML Working Group through the Joint HTML and PFWG Accessibility Task Force (A11Y TF). Task Force Sub-Groups in the areas of text alternatives, Canvas, media, and WAI-ARIA will continue their work on accessibility feature support. The Task Force will closely monitor the processing of accessibility issues during the Last Call period. We encourage people to coordinate with the Task Force on improving accessibility support in HTML5. Comments describing unmet use cases, as well as technical details, are particularly useful.
W3C has made it clear that HTML5 must meet W3C's commitment to accessibility. Your comments can help clarify what is needed to ensure that HTML5 provides support for accessibility.
Due to the timeline, the group postponed resolving some issues that were raised prior to Last Call; the group will now address them. In addition, there were objections to some decisions made prior to last call, and the group may revisit some of those. Other issues that were closed may be reopened based on new information (the accessibility issue related to the longdesc attribute is already reopened for example). The Working Group will use its decision policy to address these issues.
So while HTML5 is not yet a standard, we are making tangible progress, which is very exciting.
The Last Call review period extends until 3 August and we welcome your feedback. Note that the group will use the same process for managing issues in order to reach the next process transition by January 2012.
In the meantime, the testing effort is continuing. We have 1276 approved test cases, and 28,858 submitted ones. We still need more tests to ensure better coverage. The Group will also open itself to discussion on what to do for "HTML.next". We welcome ideas.
]]><div xmlns:v="http://rdf.data-vocabulary.org/#" typeof="v:Review"> <span property="v:itemreviewed">L’Amourita Pizza</span> Reviewed by <span property="v:reviewer">Ulysses Grant</span> on <span property="v:dtreviewed" content="2009-01-06">Jan 6</span>. <span property="v:summary">Delicious, tasty pizza on Eastlake!</span> <span property="v:description">L'Amourita serves up traditional wood-fired Neapolitan-style pizza, brought to your table promptly and without fuss. An ideal neighborhood pizza joint.</span> Rating: <span property="v:rating">4.5</span> </div>
The most important change is that RDFa 1.1 has moved away from
using XML namespaces as a syntax for identifying vocabularies. In
the simplest case, the @vocab
attribute can be used to identify a vocabulary as follows:
<div vocab="http://rdf.data-vocabulary.org/#" typeof="Review"> <span property="itemreviewed">L’Amourita Pizza</span> Reviewed by <span property="reviewer">Ulysses Grant</span> on <span property="dtreviewed" content="2009-01-06">Jan 6</span>. <span property="summary">Delicious, tasty pizza on Eastlake!</span> <span property="description">L'Amourita serves up traditional wood-fired Neapolitan-style pizza, brought to your table promptly and without fuss. An ideal neighborhood pizza joint.</span> Rating: <span property="rating">4.5</span> </div>
The change looks small, but it means that the author has less
complexity to worry about. Of course, the @vocab
attribute may be placed somewhere up in the hierarchy, e.g., on
the body element; this may become interesting if the
same page reviews not only a pizza but, say, cannelloni, too.
It is also interesting to compare the last code extract with the microdata example provided by Google for the same case:
<div itemscope itemtype="http://data-vocabulary.org/Review"> <span itemprop="itemreviewed">L’Amourita Pizza</span> Reviewed by
<span itemprop="reviewer">Ulysses Grant</span> on <time itemprop="dtreviewed" datetime="2009-01-06">Jan 6</time>. <span itemprop="summary">Delicious, tasty pizza in Eastlake!</span> <span itemprop="description">L'Amourita serves up traditional wood-fired
Neapolitan-style pizza, brought to your table promptly and without fuss.
An ideal neighborhood pizza joint.</span> Rating:
<span itemprop="rating">4.5</span> </div>
Almost identical in terms of simplicity (or complexity, if you
prefer); there is no real difference between the two. Which is,
actually, to be expected: indeed, the example concentrates on what
one could call a “single-vocabulary” case (whereby I mean that the
structured data uses terms from within the same vocabulary). One
of the main design goals of RDFa 1.1 (compared to
the previous
RDFa version) was to simplify such simple cases.
However, the same structured data in HTML may be used for other purposes, in which case one would possibly prefer to add additional terms. As a simple example, one might want to add the address of the restaurant using the vcard vocabulary; this is the case where prefixes do come handy. Indeed, one could add a few lines:
<div vocab="http://rdf.data-vocabulary.org/#" typeof="Review"> <span property="itemreviewed">L’Amourita Pizza</span> Reviewed by <span property="reviewer">Ulysses Grant</span> on <span property="dtreviewed" content="2009-01-06">Jan 6</span>. <span property="summary">Delicious, tasty pizza on Eastlake!</span> <span property="description">L'Amourita serves up traditional wood-fired Neapolitan-style pizza, brought to your table promptly and without fuss. An ideal neighborhood pizza joint.</span> Rating: <span property="rating">4.5</span>; Address: <span property="vcard:street-address">111 Lake Drive</span>, <span property="vcard:locality">WonderCity</span>, <span property="vcard:postal-code">5555</span>, <span property="vcard:country-name">Australia</span>.
</div>
which is just marginally more complicated than the previous case
with the additional vcard properties. One could have
sprinkled the code with other vocabulary elements, using Dublin
Core or other review vocabularies, etc.
At first glance, this code does not look valid in RDFa 1.1,
because there is no prefix declaration for vcard.
This is correct, and should be added using the @prefix
attribute. Except that… the profile mechanism of RDFa might become
handy here: one could imagine Google (or the site hosting the
review) defining a snippet profile including all the terms that
Google recognizes directly but which could also contain prefixes
for a number of well known other vocabularies (whether Google uses
it in the search pages or not). If so, the only change to the code
could be:
<div profile="http://google.profile.example.org" typeof="Review"> <span property="itemreviewed">L’Amourita Pizza</span> Reviewed by <span property="reviewer">Ulysses Grant</span> on <span property="dtreviewed" content="2009-01-06">Jan 6</span>. <span property="summary">Delicious, tasty pizza on Eastlake!</span> <span property="description">L'Amourita serves up traditional wood-fired Neapolitan-style pizza, brought to your table promptly and without fuss. An ideal neighborhood pizza joint.</span> Rating: <span property="rating">4.5</span>; Address: <span property="vcard:street-address">111 Lake Drive</span>, <span property="vcard:locality">WonderCity</span>, <span property="vcard:postal-code">5555</span>, <span property="vcard:country-name">Australia</span>. </div>
Actually… the vcard case, specifically, may be even
easier. Indeed, RDFa 1.1 has the notion of a default
profile, i.e., a small set of vocabulary prefixes that are
“predefined”. Although the exact list of those prefixes is not yet
fixed, we can expect that vcard will be one of
those, being one of the most widely used vocabularies around.
I.e., the code may be valid RDFa 1.1 after all…
The key point here: RDFa 1.1 brings in an open architecture that scales to authors adding structured data mixing in with ease whatever vocabulary their application needs. Scaling, the possibility to use several vocabularies with ease is RDFa’s real strength, though this is often forgotten. And that openness matters. Take, for example, the BestBuy case. They started with the simple snippet case (yielding real benefit from it, thanks to Google or Yahoo!) but then they added new features with new vocabularies, and extended the functionality for other uses (e.g., to identify shops where a specific item is to available). As so often, openness counts in the long term, also for structured data…
]]>The HTML WG is a bit specific though. A lot of what is inside in the HTML5 specification has been motivated by describing what browsers were already doing on the Web. This is far to be perfect. There is still discrepancies in between implementations, but it is a lot better than before. If you authorize me to share my own opinion, the specification needs to be implemented by more authoring tools developers to be able to give practical feedback on the specification.
The weekly summary of the Open Web Platform might then change a bit. Though there is more to cover than just the HTML WG.
There was no HTML WG desisions this week. Paul Cotton (Microsoft, co-chair) has sent a Last Call decision poll. These following documents are covered by the poll.
Paul Cotton also sent a detailed timeline for Last Call.
This column is written by Karl Dubost, working in the Developer Relations & Tools at Opera Software.
]]>