Yahoo! User Interface Blog

YUI Community Awards

February 27, 2008 at 8:45 am by Eric Miraglia | In Development | 4 Comments

At the YUI 2nd Birthday Party last night in Sunnyvale, we acknowledged several members of the YUI Community who, through their work on the community forums or elsewhere, have made outsized contributions to the YUI project by assisting fellow developers around the world. Because this kind of community-building and support is an act of generosity that makes the world a smaller place, we chose to acknowledge the fabulous work of the five recipients with gift certificates to Kiva.org, a website that enables person-to-person microlending around the world.

Here are the recipients of the first annual round of YUI Community Awards.

---

Satyam

For being the bedrock of the YUI community; for always having the right answer and the generosity to write it down; for being more productive in “retirement” than most of us ever are before retirement. (And let’s not forget the contributions to documentation, the terrific blog articles on DataTable, and the wise counsel on projects in the pipeline.)

Caridy Patiño Mayea

For the Bubbling Library and the help it’s provided to its users; for being able to answer questions about any YUI component (even really hard questions); for writing great examples and contributing to the YUIBlog. Bienvenidos a Miami, Caridy!

Jing Ceawlin

For being there with a Chinese translation on the spur of the moment; for being a voice of wisdom and reason on the community forum; for your versatility, insight and thoughtfulness in helping YUI developers discover the power of the library in their projects.

Satyen Desai

For untiring affability and completeness in answering questions; for treating rookies with respect and for treating even experts to an ongoing education; for setting the highest possible standard for the community.

Dav Glass

For reminding everyone that there’s nothing better than an example to help get someone unstuck; for being ridiculously prolific and imaginative; for writing the best one-line emails ever.

---

Satyam, Caridy, Jing, Dav, Satyen, and all the other fantastic forum contributors — a heartfelt thanks from everyone on the forum and everyone here at Yahoo on the YUI team.

Find conversations: bloglines | technorati

Share and extend: Bookmark with Yahoo! My Web | Bookmark with del.icio.us | digg it! | reddit!

Christian Heilmann’s Talk on YUI at GeekUp Leeds

February 26, 2008 at 10:34 am by Eric Miraglia | In YUI Theater | 3 Comments

Yahoo UK technical evangelist Christian Heilmann made his way to Leeds last week to give a talk on YUI for the GeekUp folks. The Northcast web podcast team has video of that talk online if you’d like to take a look. They did a fantastic job with their pre/post-roll — not too many tech videos show you the beer being dispensed prior to the talk. Don’t think that we at the YUI Theater aren’t taking notice!

You can:

• View the video on the Northcast site;
• Download the video (.avi);
• Checkout Chris’s slides on Slideshare.

Find conversations: bloglines | technorati

Share and extend: Bookmark with Yahoo! My Web | Bookmark with del.icio.us | digg it! | reddit!

AIR 1.0 and YUI

February 25, 2008 at 11:30 am by Eric Miraglia | In Development | 10 Comments

Adobe released AIR 1.0 today — great news for web application authors everywhere who now have one more compelling platform on which to deliver their products, and a platform that extends their reach into desktop space.

As you’d expect from AIR, which embeds an A-Grade version of the Webkit foundation that underpins Apple’s Safari browser, most JavaScript libraries work well and do just what you’d expect in AIR. YUI is no exception. We’ve been tracking AIR’s progress over the past several months, and we’re happy to share with you a showcase YUI app written in AIR 1.0 by YUI engineer Dav Glass. This application is based on Dav’s “Complex Example” for YUI, which brings together a broad cross-section of YUI components, and it’s a nice proof of concept for what YUI can do in the context of your AIR applications.

The following YUI components are employed in Dav’s application:

YUI Core:

• Yahoo Global Object
• Dom Collection
• Event Utility

YUI Utilities:

• Animation Utility
• Selector Utility
• Get Utility (note: the AIR sandbox prevents you from loading external script files, but Get otherwise works as expected)
• YUI Loader (note: due to limitations in the AIR sandbox, YUI Loader should be used to load YUI files that are packaged in your AIR application)

YUI Controls:

• AutoComplete Control (note: see below for an important note on AutoComplete in AIR)
• Button Control
• Calendar Control
• DataTable Control
• Rich Text Editor
• Layout Manager
• Logger Control
• Menu Control
• SimpleDialog Control
• Slider Control
• TabView Control
• Tooltip Control

We’re continuing to work on some aspects of YUI that are not compatible with AIR. The most significant issues we’re working to address are these:

• JSON support in DataTable: Currently, DataTable’s JSON parsing routines are not compatible with AIR 1.0. We expect to address this in YUI 2.5.1 next month.
• Rich Text Editor: Dav patched Rich Text Editor for his demo AIR application above, making some adjustments with respect to how AIR handles the loading of content in frames. In YUI 2.5.1, we’ll add unified support in RTE for AIR addressing this and several other issues.
• AutoComplete: The AutoComplete Control today is not compatible with AIR when using JSON datasources. We will address this issue in a future release.

AIR is a unique environment that has its own set of nuances and quirks, some of which will doubtless affect your applications as you migrate them from pure browser-based deployments into the AIR context. The issues above are the ones we know of today that are YUI-specific. Based on Dav’s experience converting the Complex Example to Air, we’re excited about the role YUI can play in AIR apps and looking forward to addressing those few core issues that remain.

Find conversations: bloglines | technorati

Share and extend: Bookmark with Yahoo! My Web | Bookmark with del.icio.us | digg it! | reddit!

A Peek Under the Hood of YUI’s DataTable Control in 2.5.0

February 25, 2008 at 10:25 am by Jenny Han Donnelly and Luke Smith | In Development | 5 Comments

We think the 2.5.0 release of the YUI DataTable Control is our best one yet, so we wanted to take a moment to look back at some of the challenges we’ve faced over the past few months and to peek under the hood at some of the techniques we’ve used to tackle these problems.

A Yielding Render Queue

The browser environment presents non-trivial challenges for application developers, including security sandboxes and limits to CPU and memory. The DataTable is a large and robust application even before you load it up with data, and one of the core challenges for us has been to improve performance as more and more data is brought into the table. In previous releases, the browser’s UI thread would tend to lock up after a certain data-size threshold was crossed as DataTable churned through the management of its internal objects and the DOM.

We’ve made huge improvements in DataSource to help speed things up on the data processing side, but there remained the issue of rendering all this data to the UI. Modifying the DOM can get expensive quickly, especially when you’re talking about drawing or updating hundreds of rows with several cells per row.

Browsers are impatient; they like to get to work updating the display as soon as something is changed in the DOM. While we appreciate the enthusiasm, this model can be counterproductive when a lot of changes need to be made — such as rendering a DataTable with hundreds of rows. After each DOM change, the browser prepares to update the UI, but it won’t actually redraw the UI until the JavaScript has finished executing. In effect, all the preparatory work done between subsequent DOM updates needlessly pulls resources away from the remaining work that needs to be done. All the while, the UI sits there unchanged.

To address this issue, we’ve introduced progressive rendering to the new version of DataTable.

By default, progressive rendering isn’t turned on, as the benefit is mostly evident for tables in excess of 50 rows. To enable progressive rendering, set the DataTable’s renderLoopSize configuration to the number of rows you want rendered per iteration. For example, to configure your DataTable to draw 20 rows at a time:

var myDataSource = new YAHOO.util.DataSource(myHugeDataSet);
myDataSource.responseType = YAHOO.util.DataSource.TYPE_JSARRAY;
myDataSource.responseSchema = { fields : [ "id","name","age" ] };

var myColumnDefs = [ {key:"id"}, {key:"name"}, {key:"age"} ];

var myTableConfig = { renderLoopSize : 20 };

var myDataTable = new YAHOO.widget.DataTable('tbl', myColumnDefs, myDataSource, myTableConfig);

Supposing myHugeDataSet contains 412 records, the DataTable will immediately render itself in an empty state, then milliseconds later 20 rows will appear, then 20 more rows, and so on until all of the 412 rows are displayed.

Scrolling This Way and That Way

The scrollability feature, which was too fragile in previous releases, warranted a markup overhaul to give DataTable a more solid foundation to support fixed-header scrolling plus horizontal scrolling. Our challenge was to achieve a stable xy-scrolling mechanism while remaining accessible to screenreaders. (Screenreader software, which assists blind or partially sighted users, is good at handling <table> elements and their contents; it doesn’t do well with tabular data that’s marked up in other ways [such as in <div>s]. For a general introduction to screenreaders, check out this YUI Theater video.)

To start, the simplest way to achieve scrolling was to split DataTable markup into two <table> elements each housed in their own containers with their own overflow styles. Next, because of our built-in support for nested headers, we wanted to keep <td> "header" attributes as the best technique to allow screenreaders to make sense of our content. Trouble was, without <th> elements, these "header" attributes were meaningless. We were forced to duplicate all the markup of the <thead> of the first <table> in another <thead> in the second <table>. A quick absolute-positioning of the second <thead> to the far-left places these meant-for-screenreaders-only elements offscreen.

A Fresh Look at Pagination

Pagination is such a fast way to reduce the footprint of a large dataset that we found ourselves recommending this feature to a lot of our implementers. Problem was, everybody seemed to have different expectations when it comes to pagination. The challenge here was to create a solution simple enough for the plug-and-play needs of some, but flexible enough for implementers with highly customized requirements. The result of our efforts is the new YAHOO.widget.Paginator class (currently packaged with the DataTable build).

Before we tell the interesting story, here’s the less interesting one. To paginate your DataTable, all your Paginator needs to know is how many rowsPerPage you want to display. The rest it can figure out on its own.

var myTableConfig = {
  paginator: new YAHOO.widget.Paginator({rowsPerPage:50})
  };
var myDataTable = new YAHOO.widget.DataTable(
  myContainer, myColumnDefs, myDataSource, myTableConfig);

Of course, dividing a total number of records by a set number of rows per page is simple math. That part is easy to code. It’s in the UI implementation that things get dicey.

To tackle this problem, Paginator is build on a template and UI component system. The template config contains the markup describing how the pagination controls should be rendered. The default template looks like this:

"{FirstPageLink} {PreviousPageLink} {PageLinks} {NextPageLink} {LastPageLink}"

Each bracketed item is a placeholder identifying where to render one of Paginator’s UI components. The following UI components are available with the 2.5.0 release:

• FirstPageLink
• PreviousPageLink
• NextPageLink
• LastPageLink
• PageLinks
• RowsPerPageDropdown
• CurrentPageReport

Each component adds its own configuration options to the Paginator, allowing you to customize its look and feel. For example, this configuration…

var myPaginator = new YAHOO.widget.Paginator({
  rowsPerPage : 25,
  template : "{PreviousPageLink} <span>{CurrentPageReport}</span> {NextPageLink}",
  previousPageLinkLabel : ‘&lt;’,
  nextPageLinkLabel : ‘&gt;’,
  pageReportTemplate : ‘Showing records <strong>{startRecord} – {endRecord}</strong> of {totalRecords}’
  });

…would result in pagination controls rendered like this:

Take a look at the classes under the YAHOO.widget.Paginator.ui namespace in DataTable’s API docs for a list of each component’s options.

Of course, if none of the pre-packaged UI components suits your needs, you can create your own components. Just drop them in the YAHOO.widget.Paginator.ui namespace and you can immediately reference them by name in your Paginator template and config. And if you create a cool Paginator component, let us know in the comments or on the YUI community forum — we’d love to see what you build with this, as would other DataTable users.

Columns Get Their Day

Version 2.5.0 introduces a new set of APIs for managing Columns in the DataTable: setting widths, hiding and showing, inserting, removing, and drag-and-drop reordering of Columns are now supported out of the box. Hiding and showing of Columns is implemented by setting a column’s width to "1px" on hide and and reverting to the original width on show. Inserting a Column requires passing in an object literal Column definition. This will create a new Column instance, add it to the internal ColumnSet, and update the DOM as necessary. Removing a Column will remove the Column instance from the ColumnSet as well as removing all related elements from the DOM. Drag-and-drop reordering of Columns can be enabled for the entire DataTable via the constructor config, as long as the Drag and Drop Utility is available on the page. When a Column is reordered, it is first removed from the DataTable and then inserted into the new position.

Since Columns can be assigned a width at instantiation or dynamically at runtime, users can easily resize their Column widths and then save their settings as a preference for their next visit using the Cookie Utility that Nicholas C. Zakas contributed to YUI for the 2.5.0 release. Here’s one way you might achieve that:

var Cookie = YAHOO.util.Cookie;
var Dom = YAHOO.util.Dom;

var myData = [
  {SKU:"23-23874", Quantity:43, Item:"Helmet", Description:"Red baseball helmet. Size: Large."},
  {SKU:"48-38835", Quantity:84, Item:"Football", Description:"Leather football."},
  {SKU:"84-84848", Quantity:31, Item:"Goggles", Description:"Light blue swim goggles"},
  {SKU:"84-84843", Quantity:56, Item:"Badminton Set", Description:"Set of 2 badminton rackets, net, and 3 birdies."},
  {SKU:"84-39321", Quantity:128, Item:"Tennis Balls", Description:"Canister of 3 tennis balls."},
  {SKU:"39-48949", Quantity:55, Item:"Snowboard", Description:""},
  {SKU:"99-28128", Quantity:77, Item:"Cleats", Description:"Soccer cleats. Size: 10."},
  {SKU:"83-48281", Quantity:65, Item:"Volleyball", Description:""},
  {SKU:"89-32811", Quantity:12, Item:"Sweatband", Description:"Blue sweatband. Size: Medium."},
  {SKU:"28-22847", Quantity:43, Item:"Golf Set", Description:"Set of 9 golf clubs and bag."},
  {SKU:"38-38281", Quantity:1, Item:"Basketball Shorts", Description:"Green basketball shorts. Size: Small."},
  {SKU:"82-38333", Quantity:288, Item:"Lip balm", Description:"Lip balm. Flavor: Cherry."},
  {SKU:"21-38485", Quantity:177, Item:"Ping Pong Ball", Description:""},
  {SKU:"83-38285", Quantity:87, Item:"Hockey Puck", Description:"Glow-in-the-dark hockey puck."}
  ];
  
  // Grab cookies when possible
  var myColumns = [
  {key:"SKU", resizeable:true, width:parseInt(Cookie.get("SKU"),10)||null},
  {key:"Quantity", resizeable:true,width:parseInt(Cookie.get("Quantity"),10)||null},
  {key:"Item", resizeable:true,width:parseInt(Cookie.get("Item"),10)||null},
  {key:"Description", resizeable:true,width:parseInt(Cookie.get("Description"),10)||null}
  ]
  
  var myDataSource = new YAHOO.util.DataSource(myData,{
  responseType: YAHOO.util.DataSource.TYPE_JSARRAY,
  responseSchema: { fields: ["SKU", "Quantity", "Item", "Description"] }
  });
  
  var myDataTable = new YAHOO.widget.DataTable("myContainer", myColumns, myDataSource);
  
  myDataTable.subscribe("columnResizeEvent", function(oArg) {
  // Coming soon: width value from the event.
  // Until then, manually calculate.
  var el = oArg.target.firstChild;
  var newWidth = el.offsetWidth -
  (parseInt(Dom.getStyle(el,"paddingLeft"),10)|0) -
  (parseInt(Dom.getStyle(el,"paddingRight"),10)|0);
  
  // Set the cookie
  Cookie.set(oArg.column.getKey(), newWidth, {
  path: "/",
  domain: "yahoo.com",
  expires: new Date("January 12, 2025")
  });
  });

There is No “Rest” in Iteration

2.5.0 is a big release for DataTable, but our work is not done, and we’re already tackling our next set of top issues, including better support of server-side sort and pagination, more performance enhancements with dynamically added and removed data, and more robust screenreader accessibility for dynamic states.

We want to take this chance to thank all the members of the community who have taken the time to implement our products, file bugs, suggest features, and contribute to the forum (this means you, Satyam!). Your participation is wholly appreciated and makes an incredible difference in what we do and how we do it.

Find conversations: bloglines | technorati

Share and extend: Bookmark with Yahoo! My Web | Bookmark with del.icio.us | digg it! | reddit!

Satyam’s DataTable Examples Updated for 2.5.0

February 21, 2008 at 5:40 pm by Eric Miraglia | In Development | 3 Comments

Satyam, one of the esteemed cornerstones of the YUI community, has been busy since yesterday’s YUI 2.5.0 release — his independent examples collection for the DataTable Control is already up-to-date with the 2.5.0 changes that Jenny Han Donnelly and Luke Smith have made for that component.

From Satyam himself:

I’ve just finished uploading my DataTable examples for 2.5.0. The index now has links to both the 2.4 version and the the 2.5 and comments specific to the new version which you might want to read about. I still have to fix a few things in the new ones, but they work, more or less.

http://www.satyam.com.ar/yui/

Continuing thanks to Satyam from all of us here for his many contributions.

Find conversations: bloglines | technorati

Share and extend: Bookmark with Yahoo! My Web | Bookmark with del.icio.us | digg it! | reddit!

YUI 2.5.0 Released — Big upgrades to DataTable, new Layout Manager, Flickr-style multi-file Uploader, and more

February 20, 2008 at 10:44 am by Eric Miraglia | In Development | 67 Comments

The YUI Team just released version 2.5.0 of the library. We’ve added six new components — Layout Manager, Uploader (multi-file upload engine combining Flash and JavaScript), Resize Utility, ImageCropper, Cookie Utility and a ProfilerViewer Control that works in tandem with the YUI Profiler. This release also contains major improvements to the DataTable Control and new Dual-Thumb Slider functionality in the Slider Control. Here are the highlights:

• DataTable Control: Jenny Han Donnelly has been joined by Luke Smith for this development cycle, and we’re all thrilled with what they’ve produced. DataTable in 2.5.0 gets a more robust markup structure that allows greater control over all aspects of the table. This release also includes major performance enhancements, improvements to the fixed-header implementation for vertical scrolling, built-in support for horizontal scrollling, an all-new Paginator class, support for drag-and-drop column reordering, and a new set of column APIs with hooks for showing, hiding, adding and removing columns.
  
  DataTable has been one of YUI’s most popular and important components since its debut, and this is its strongest release yet. If you have existing DataTable implementations that you want to upgrade, take a look at the new User’s Guide, as it has some detailed notes about API changes. The DataTable examples roster is another nice place to check out the new code in action.
• Layout Manager: Dav Glass has a lot for you to enjoy in 2.5.0, but top billing goes to his new Layout Manager. Layout Manager eases development of multipane UIs that take up either the full viewport or the full canvas of any block-level element. Layout Units within a layout are resizeable, collapsible, removable and swappable; transitions between expanded and collapsed states have built-in animation support. Whether you’re creating a full-screen application like Yahoo! Mail or a rich multi-pane pop-up, Layout Manager is a great place to start.
• Uploader: If you’ve ever built a UI for uploading files via a browser, you know what the big pain points are: One file at a time, no easy way to track upload progress, no programmatic access to file metadata, etc. The new YUI Uploader addresses these issues and others, allowing for the creation of more powerful, intuitive, and responsive file upload experiences. Allen Rabinovich of the ASTRA Library team did the legwork on this one, and it’s the same code that underlies the Flickr Uploader. Uploader is our second JavaScript/Flash hybrid control (following on the heels of the Charts Control in 2.4.0).
  
• Resize Utility: Layout Manager is built upon a new YUI utility, Resize. Dav’s Resize Utility formalizes the support that YUI Drag & Drop has long provided in example form and makes it easier for you to make any block-level element resizeable. Resizing can be implemented directly (the resized element resizes in real time during the interaction) or by proxy (a proxy element visualizes the interaction until its conclusion, at which time the resized element snaps to its new size).
• ImageCropper Control: The Resize Utility makes a lot of things easier — and one of those is the implementation of an ImageCropper interface, which Dav built out on top of Resize for 2.5.0. Take a look at the examples and be sure to check out the support Dav provided for modifier keys in this very desktop-like UI control.
• Cookie Utility: When he’s not busy writing books or working on My Yahoo!, Nicholas C. Zakas is cranking out new code for YUI. In 2.5.0, he contributes the Cookie Utility, a simple but powerful component that helps you get maximum mileage out of your limited cookie space. Because browsers limit the number of cookies you can set per domain (and because that limitation can sneak up on you if you manage a large site with many subdomains), the Cookie Utility supports "sub-cookies." Sub-cookies pack multiple name-value pairs under the umbrella of a single cookie, expanding the number of data points that you can store in cookie space.
• ProfilerViewer Control: 2.4.0 saw the release of Nicholas’s Profiler, a headless, cross-browser kit for profiling JavaScript functions. To make it easier to access and interpret the data that Profiler collects, we’ve added a ProfilerViewer Control in 2.5.0 that sits on top of Profiler and visulizes its accrued data. ProfilerViewer leverages the Charts Control and the DataTable Control. Taken together, Profiler and ProfilerViewer provide another arrow in the development quiver that includes tools like Firebug’s integrated profiling interface.
  
• Slider Control with Dual Thumb Support: Supporting dual-thumb interactions in our Slider Control has been on our list for awhile, and Luke took the opportunity to get this out to you in 2.5.0. Sliders are “finite range controls”; dual-thumb sliders allow you specify a sub-range within the control’s larger range. The classic use case for dual-thumb sliders is on shopping sites, where such controls can allow users to filter results based on price range. Check out the User’s Guide, example, and the new Slider Cheatsheet (which has a second page dedicated to dual-thumb implementations).
• We’re using this release to promote the following components from beta to GA status: ColorPicker Control, Get Utility (for cross-domain, dynamic loading of script and CSS files), JSON Utility, ImageLoader Utility, and YUI Test Utility. These promotions reflect the maturity of those components and their very low bug traffic. As always, we’re releasing all new-for-2.5.0 components under the beta moniker, and we’re looking forward to your feedback on those once you get a chance to try them out.
• Full details on the release, including a rollup of the changelog for all components and a bug/feature manifest, are available in Georgiann Puckett’s update to the YUI developer forum this morning.

One More Thing…

YUI now ships with more than 270 examples, many of which are accompanied by full tutorials to help you get started using YUI. And while individual examples are good, we’ve gotten a number of requests to create an über example, one that pulls in and makes use of a wide range of YUI components in a single sample application — while still being YUI-centric and not littered with noisy implementation logic.

The incomparably prolific Dav Glass rose to the challenge for 2.5.0 with a complex, multi-component example that uses Layout Manager as its basis and Yahoo Mail as its inspiration.

Let’s Celebrate!

We’re excited to get 2.5.0 out the door and, as luck would have it, we’ve got a fantastic excuse to celebrate. YUI’s (and the Yahoo Pattern Library’s) second anniversary party is coming up next week (February 26, 5 p.m., Sunnyvale), and we’d love to have you join us. Sign up on Upcoming to let us know you’ll be stopping by at Yahoo! HQ for some beer and general revelry. We look forward to showing off some of the stuff you all have been doing with YUI in the past two years and we’ll talk a bit about where Patterns and YUI are headed from here.

Find conversations: bloglines | technorati

Share and extend: Bookmark with Yahoo! My Web | Bookmark with del.icio.us | digg it! | reddit!

Graded Browser Support: Updated A-Grade Chart

February 19, 2008 at 1:42 pm by Nate Koechley | In Development | 10 Comments

This post marks the first Graded Browser Support (GBS) update of 2008. It modifies the A-Grade support chart and offers a forecast of likely future changes. The current A-Grade support chart is always on the YUI web site; updates are always announced here.

There are three main changes in this update:

• Safari 3 begins receiving A-Grade support on Mac 10.4 and 10.5
• Safari 2 stops receiving A-Grade support.
• Firefox 1.5 stops receiving A-Grade support.

Current A-Grade Support Chart

GBS Forecast

In addition to the effective-immediately changes, we’re also keeping our eyes on some pending developments.

• Firefox 3 and Internet Explorer 8

  GBS does not extend A-Grade support to beta versions of browsers. (They receive X-Grade support by definition.) However, it’s important to be aware of forthcoming releases, especially from established brands that enjoy rapid adoption once generally available (GA). We are currently watching the development progress of Firefox 3 and Internet Explorer 8.

  We made an exception to our “no betas” stance during IE7’s beta phase in recognition of IE’s market share and ability to promote rapid adoption. These exceptions — committing development and QA resources to provide A-Grade support prior to a GA release — give us an opportunity to learn the new browser’s quirks and provide feedback while it is still being developed. And it means our sites are prepared when it does reach GA. We will likely extend the same accommodation to IE8. Stay tuned.

• Windows 98

  We anticipate that in the next GBS update we will discontinue A-Grade support for browsers running on Windows 98.

Other Notes

• YUI 2.5.0, released earlier this week, still provides A-Grade support to Safari 2. It’s unlikely that future YUI release will. For now: bonus browser support!

• We are going to begin archiving these individual updates more than we’ve done in the past. We’ve heard your request to have snapshots of the GBS chart at a particular moment in time. We plan to publish these detailed updates on this blog, and collect the links to the various updates in a new Archive section of the web site.

• Currently browsers receiving A-Grade support are the only ones enumerated in chart form. I’ve heard your requests to see the other charts, and I’d sincerely hoped to have those ready to share by now. Unfortunately, some associated tools are not yet complete. But I’m working on it!

Find conversations: bloglines | technorati

Share and extend: Bookmark with Yahoo! My Web | Bookmark with del.icio.us | digg it! | reddit!