As I was invited to talk about “Web 2.0″ a month ago at the WITFOR conference, I wanted to use a graphic that would illustrate Tim O’Reilly’s definition of Web 2.0 in 7 points.

I started to look for existing illustrations that I could re-use, but while there are many illustrations of what Web 2.0 is in general, I didn’t find any that focused on Tim’s “official” definition; since a big part of the message I wanted to convey was that Web 2.0 was not (only) a buzzword but was actually a fairly well-defined concept, I couldn’t just re-use any of these vague illustrations.

So I came up with the following illustrations (thanks to InkScape and OpenClipArt) that I’m releasing under a creative common license in the hope that they can be re-used and improved.

“Web 1.0″ Illustrated by Dominique Hazael-Massieux
licensed under a Creative Commons Attribution-Noncommercial-Share Alike 3.0 United States License.
(original SVG)

Web 2.0 Illustrated by Dominique Hazael-Massieux
licensed under a Creative Commons Attribution-Noncommercial-Share Alike 3.0 United States License.
(original SVG)

The result of that interesting mix is that we have set up over time a fairly large number of tools to facilitate collaboration: several hundreds of mailing lists, an IRC server with a few handy bots, a fine-grained access control system, a questionnaire system, a flexible editing system combined with a robust mirroring scheme, wikis, blogs, various bug and issues tracking system, etc.

And as all these tools are entirely bug-free and work seamlessly together and for all our users (NOT!), we have always had a need to track requests from our users to create and manage various accounts, set up new instances of these tools, correct or work around bugs, etc.

Over the years, the way we have tracked and managed all these requests has evolved, toward somewhat more formalism as the number of our users and tools grew.

When I joined the Systems Team in 2000, our tracking was entirely based on manual scanning of mails threads sent to one of our internal mailing lists: basically, each of us watched for what looked like a request, checked if anybody had responded to it, and if nobody had and the request was something you could manage, and you had some time on your hands, you would take on it.

Given how informal it was, it actually worked quite well, although over time we added some more purely conventional practices: requiring the use of a specific mailing list of a specific type of requests, adding a [closed] flag to the topic of a thread to signal that the request had been dealt with (so that others could simply delete the thread without bothering reading it).

But as the number of tools and users continued to grow, we started to get complaints that some requests had not been dealt with at all, and it became clear that we lacked overall visibility on what needed to be responded.

Back in 2002, I wrote a quick XSLT style sheet that would help us get more visibility on the state of our requests: it took the threaded view of the archive of our request mailing list, and would look for any thread that didn't contain a message starting with our now conventional [closed] flag, and would present a report showing all the requests that hadn't been closed, as well as those that hadn't had an answer at all.

And again, that fairly simple system served us well for quite a few years; some others W3C groups even started re-using it for tracking their issues, and a similar version of the tool based on more Semantic Web technologies was used by a couple of groups to track their specifications' Last Call comments.

But no matter how well that solution worked, we decided last year that we would finally move to a proper tickets tracking system, the well-known open-source RT, to get the following advantages over our existing hack:

• get a clear view of who was working on what ticket,
• be able to assign a given ticket to someone, even if that person hadn't picked it up yet
• easily find tickets that were stalled due to lack of responses from the requester (vs. because we didn't act on it)

The first few months with RT weren't quite so rosy, actually, as we had to find ways to integrate it as smoothly as possible in our current procedures and infrastructures, and with our mailing list habits.

Some of the changes we've brought to it include:

• make it track messages sent as part of a given thread (as identified by the In-Reply-To header) as belonging to the same ticket (even without the id number included) - with an an existing patch to that end;
• change the way it modified subject messages (with the Branded Queues extension);
• fix partially the way it sends messages and notices through the configuration UI;
• make it understand our [closed] convention so that we could continue using mail as our primary way to close a ticket, using a simple "Scrip" inspired from another RT user's contribution.

There are still some rough edges - RT seems to be particularly reluctant to send messages in CC when using the Web interface for some reasons, we need to integrate it better with our existing accounts system so that our users can better follow progress on their requests -, and some user interface and HTTP behaviors problems that make me cringe.

But overall, I think the tool has certainly helped us regain control over our growing number of requests, and is also hopefully steadily allowing us to offer a better experience to our community.

Twitter and friends have been around for quite some time now, and microblogging hadn’t really appealed to me, despite a few experiments here and there; I had started to follow some colleagues and friends tweets by subscribing to the resulting RSS feeds, but hadn’t really found a good motivation to use it to generate content.

I think I’m now getting into it, although I can’t say that I have a lot of experience on it yet :)

So what is nice about joining one of the microblogging platforms out there?

• the expectations on the originalty and novelty of the posted content are much lower than on blogs – which themselves are often thought as requiring less polishing than a formal article; this means probably an overall lower signal/noise ratio, but this also means that information can flow much more freely; as such, it seems to be a great platform for serependity;
• I had completely (and probably ironically) undervalued the social nature of the microblogging platforms – the incentive in keeping your micropost interesting, fun, or original is provided by the number of people that follow you; while of course blogs are also followed and can be measured by that metrics, the fact that the microblogging platforms include the number of followers right next to your posts list, publishes your avatar on next to the posts list of people following you, and notify you of new followers, makes it a strong feedback channel. Some blogging platforms do the same (e.g. LiveJournal), but given that Twitter more or less centralizes today all the microblog users, the chances that people you care about actually are on Twitter are much higher;
• both blogging and microblogging are great reflexive tools, but due to reduced cost of posting something on a microblog, they give a possibly more fine-grained view of a day or week;
• the self-imposed 140 characters limit to the length of texts that can be posted are also a fertile group for creativity in expression; as put by Frank Lloyd Wright, Man built most nobly when limitations were at their greatest;
• the interaction between microblogs and other systems (through REST APIs, XMPP) also seem quite promising, although I haven’t had yet great success to report on that front.

There are also obviously some frustrating aspects – the biggest one and probably their greatest weakness is the fact that Twitter is such a giant at the center of that world; even though I use Identi.ca as my primary account, it was quickly obvious that I also needed an account on Twitter if I really wanted to interact with most people I know. Fortunately, Identi.ca allows to propagate my posts from one to the other, but I can’t follow my twitter’s subscriptions from there, nor keep track of who’s following. I think the openmicroblogging effort is precisely trying to fix that problem – may they succeed in it! (note how I try to avoid using “twitter” as a verb or noun to designate the generate phenomenon)

It is also annoying that so much of the intercommunication relies on the account name – this merges the social identity and the communication identity (a bit as if I were to call you by your phone number rather than by your name), and this creates yet another case of shortage of names. It is somewhat practical since you can address someone with a limited number of characters (compared to a full name, an email address, a URI), but seems architecturally wrong.

Also, microblogging platforms break threaded discussions; when reacting to someone’s micropost, you only get a link to that person’s microblog, not to the particular item you were reacting to; very, very frustrating when browsing through archives… I think a low-cost fix to that problem would be to have instead or in addition a link to a dated archive of that person, based on the time at which the “@” message was sent.

Finally, as many other social networking activities, microblogging tends to be extremely addictive, at least for the first few days or weeks; do I really need another net-addiction?

WBS knows a variety of types of questions that can be included in the questionnaires it creates: open comments, radio-selectable list of choices, checkboxes-selectable list of choices, timetable selector, etc. It is also (more or less weel) designed so that new types of questions can be reasonably easily added.

As part of an upcoming survey for W3C Members, it was requested that WBS handles a new type of questions, to support cumulative voting.

Adding the server-side part of that new control was relatively straightforward, thanks to WBS architecture; but given the nature of cumulative voting, it seemed more or less required to complete it with a client-side layer (read "Javascript") to ensure a minimum level of usability.

Although I started writing Javascript almost as soon as I started writing Web pages some twelve years ago, I had grown wary of doing it; I restarted coding with it lightly over the past two years, but had found it quite cumbersome to write, in particular when wanting to do it properly, that is to say with graceful degradation, events binding, proper DOM operations, etc.

So I figured that if everyone is raving about these new Javascript frameworks, there may be some reason to it and that I would better pay attention - and thus started using JQuery, mostly because it happened to be already set up on the W3C site and that I hadn't heard or read bad things about it.

Sure enough, one hour and a few tutorial pages later, I had written the 30 lines of code that were needed to support what I had in mind to ease the interactions with the cumulative voting. Quite impressive! Write less, do more seems to be right on target. The usage of CSS selectors to pick the elements on which you want to act is a bliss.

I did have to tweak the code a bit to improve its performance - my initial code didn't scale well when the number of options on which to vote went up; I fixed it up by relying on event delegation, essentially reducing the number of events binding by attaching the onChange event to the container of the select elements rather than to each of them.

For sake of illustration, let's compare the code to the one I would have needed to write without using JQuery (and not mentioning cross-browsers compatibility issues) for the first couple of lines:

window.addEventListener('load',function() {

$(document).ready(function() {

   // Adding a line to the list with the total displayed
divs = document.getElementsByTagName("div");
for(i=0;i<divs.length;i++) {
  div = divs[i];
  if (div.class=='cumulative') {
    cumulativeSelectors = div.getElementsByTagName("ul");
    for (j=0;j<cumulativeSelectors.length;j++) {
      ul = cumulativeSelectors[j];
      if (ul.class=="compare") {
        li = document.createElement("li");
        totalSpan = document.createElement("span");
        totalInput = document.createElement("input");
        remainingSpan = document.createElement("span");
        remainingInput = document.createElement("input");
        totalSpan.appendChild(document.createTextNode('Total'));
        remainingSpan.appendChild(document.createTextNode('Remaining'));
        totalSpan.class=remainingSpan.class='label';
        totalInput.disabled = remainingInput.disabled = true;
        li.appendChild(totalSpan);
        li.appendChild(document.createTextNode(':'));
        li.appendChild(totalInput);
        li.appendChild(remainingSpan);
        li.appendChild(remainingInput);
      }
    }
  }
}

   // Adding a line to the list with the total displayed
   $("div.cumulative ul.compare").append("<li><span class='label'>Total</span>:
 <input disabled='disabled' /> <span class='label'>
Remaining</span> <input disabled='disabled' /></li>");

(syntax highlighter credits go to Enjoy*Study.)

And that's taking the less complex part of the code…

I think I'm going to like coding in Javascript again! I would be curious to read the XForms equivalent of this widget - any taker?

Possible improvements to my cumulative voting widget include:

• Packaging it as a JQuery widget - this could possibly be useful to others?
• Using sliders to give a better visual feedback
• Annotating the controls with WAI ARIA for improved accessibility and usability

I had started aggregating my microblogs on this blog through feedwordpress, but found the results too noisy – in particular since this blog is syndicated on the W3C Team blogs’ galaxy where the microblogs would end up filling all the entries. I’m still looking into finding a good way to show my microblogs on this site, though; for the time being, they are a link away.

Note that Twitter doesn’t think my name can contain more than 20 characters – a curious echo to a similar problem I experienced with Air France.

We’ll see how that microblogging experiment works out; I had already been using Twitter from time to time on the mobiweb account without much regularity, but from my short experimentation, I think a personal microblog has more chances to get used.

It’s probably not as good as being here, but this is getting close, so enjoy!

But one of the big highlight of the week remains for me the Technical Plenary day: during a full day, all the participants week are put together in a big room to discuss some of the hot topics in the W3C community, based on a set of presentations and panels. As always, all the proceedings of the event are released publicly, making for a great source of knowledge available to all – you can see for yourself from the list of previous technical plenaries.

This year again, the agenda for the plenary day (on Wednesday November 7) looks like it will trigger some interesting discussions: if you can imagine a bunch of talented Web geeks – each with his or her own speciality, be it XML, HTML, Web Services, SVG, CSS, mobile, accessibility, internationalization – having a discussion on HTML5 compared to XHTML 2, or how to make W3C a more open organization, or discovering the true face of W3C (at least as perceived by outsiders), spiced up by the always-popular lightning talks, you’ll get the feeling of what an exciting day it should be.

While it isn’t as good as having the meeting opened to all – I’d love it if we could find the proper logistical arrangement to make this happen -, this year will offer a few improvements to make it even more visible to the community at large:

• in addition to the detailed minutes of the day, the audio recording of the presentations and subsequent discussions will be made available
• the press and some bloggers have been invited to report on the meeting

So, be ready to hear more from this meeting!

I’ve heard plenty of good things on last year edition of the conference, and the programme this year looks quite promising as well; so, no doubt, I’ll be there!

<dom_bene healthy='yes' happy='very' tired="very">
   <mathias start="20070913T043100Z" weight="3.265kg" cute="mostintheworld" healthy="yes" />
</dom_bene>

(and also the reason why I may have been a bit less responsive over the two past weeks…)

The first half of my self has started blogging in the MWI Team Blog a while ago – and I’m now trying to make sure to import these blog posts in this very blog as well -, and my second half has now also a new blog output available: the Systeam blog opened yesterday, and I’m hoping my colleagues and I will feed it regularly with the various hacks, open source contributions, and practical advices that we come up with.

My last WWW Conference was three years ago and didn’t leave me with great memories, but this year’s edition was certainly much better than any other WWW Conference I’ve been to, and getting close to be as inspiring as XTech was last year – I haven’t been to XTech this year, so I don’t know how good it was, but read some positive reports on the 2006 edition as well.

Clearly, one of the major improvements for me was the extension of the previous editions’ developers day into a developers track that ran during the whole conference, rather than being concentrated at the very end; I thought it made a rather nice balance to the more theoretical and academic side of the other tracks.

My own contribution to the conference was the set up and animation of a session in the W3C track on the Mobile Web, and esp. on the prospects of what the future of the Mobile Web might be, entitled somewhat provocatively What the Mobile Web 2.0 will be?; this was the occasion to present updates on the W3C Mobile Web Initiative, but more proeminently to listen at the views of six panelists on what might make the Mobile Web the next big thing for the Web, much like “Web 2.0″ is the currently used moniker to refer to exciting stuff on the Web.

While the opinions of the panelists were quite diverse, some trends emerged out of the discussions: access to the Web on mobile devices can be of a huge importance in granting Web access to a much larger variety of people (esp. in developing countries, where access to a connected computer remains a luxury), should allow users creations and interactions in a much broader context; Rolan Geisler from Nokia also alluded to the development of a core Open Source platform for mobile devices as a way to help the industry grow the Mobile Web into a scalable development platform (matching their announcement of the open source release of the S60 browser).

In any case, it was really nice to see all the energy there was around the Mobile Web, during this session and elsewhere; hopefully our ongoing work in the Mobile Web Initiative will allow us to build on this energy.