When we launched the site, we checked it out in all our normal browsers and everything was good. Then we fired up IE 6 (unfortunately the client in question needs IE 6 support), navigated to the new secti-OH CRAP! The page itself would load, but none of the external assets (images, stylesheets and scripts) were loading. Refresh the page and bingo! it works fine! What the heck is going on?!

It turns out IE 6 was sending not one, but two referers to the web server. While it’s odd to have 2 referers, it shouldn’t cause 4xx Errors when sending a request. From this, we were able to find out a few things:

1. IIS accepts both Referer and Referrer as valid HTTP headers.
2. IIS will not accept more than one Referer.
3. IIS will accept more than one Referrer (note this is the dictionary spelling of referrer, not the spec spelling).
4. IE 6 will add 2 referrers if the link you clicked is located inside of a Flash element for all external assets: the URI to the Flash file and the URI of the page you are on.

I’m not quite sure why IE 6 behaves the way it does, but the fact is that it does and it was causing IIS to give us 400 Bad Request responses. Think I’m crazy (and maybe I am, please prove me wrong)? Try sending this request to www.microsoft.com:

HEAD / HTTP/1.1
Host: www.microsoft.com
Referer: http://google.com
Referer: http://yahoo.com
Connection: Close

In response you should get something similar to:

HTTP/1.1 400 Bad Request
Content-Length: 339
Content-Type: text/html; charset=us-ascii
Server: Microsoft-HTTPAPI/2.0
Date: Mon, 24 Aug 2009 22:53:04 GMT
Connection: close

Now send the exact same request to, say, www.apple.com:

HEAD / HTTP/1.1
Host: www.apple.com
Referer: http://google.com
Referer: http://yahoo.com
Connection: Close

and you get:

HTTP/1.1 200 OK
Age: 255
X-Cache-TTL: 345
Accept-Ranges: bytes
Date: Mon, 24 Aug 2009 22:48:41 GMT
Content-Length: 9542
Content-Type: text/html; charset=utf-8
Expires: Mon, 24 Aug 2009 22:58:41 GMT
Cache-Control: max-age=600
Server: Apache/2.2.8 (Unix)
X-Cached-Time: Mon, 24 Aug 2009 22:50:56 GMT

And now, to prove point #3, send the following request to www.microsoft.com (note the change in spellings):

HEAD / HTTP/1.1
Host: www.microsoft.com
Referrer: http://google.com
Referrer: http://yahoo.com
Connection: Close

and you get

HTTP/1.1 200 OK
Cache-Control: no-cache
Content-Length: 1020
Content-Type: text/html
Last-Modified: Mon, 16 Mar 2009 20:35:26 GMT
Accept-Ranges: bytes
ETag: "67991fbd76a6c91:0"
Server: Microsoft-IIS/7.0
P3P: CP="ALL IND DSP COR ADM CONo CUR CUSo IVAo IVDo PSA PSD TAI TELo OUR SAMo CNT COM INT NAV ONL PHY PRE PUR UNI"
X-Powered-By: ASP.NET
Date: Mon, 24 Aug 2009 23:09:03 GMT

We’ve developed a bit of code to help make your life a little easier.

Adding the code below to your functions.php file will let you remove the other children pages while on the parent page.

add_filter('wp_list_pages_excludes', 'remove_others_children');
function remove_others_children($excludes = array()) {
  $all_pages = get_pages();
  $all_children = (array) get_page_children(true, $all_pages);
  foreach ( $all_children as $child )
    $excludes[] = $child->ID;

  if ( ! is_page() )
    return $excludes;

  global $post;

  $this_heirarchy = (array) $post->ancestors;
  $this_children = (array) get_page_children($post->ID, $all_pages);
  foreach ( $this_heirarchy as $ancestor )
    $this_children = array_merge($this_children, (array) get_page_children($ancestor, $all_pages));

  foreach ($this_children as $child)
    $this_heirarchy[] = $child->ID;

  return array_diff($excludes, $this_heirarchy);
}

Here are some examples of what it would like without the code, then with the code.

A huge thanks goes out to Matt Martz for working with us on helping get this code ready.

The eXtensible Stylesheet Language (XSL) is a family of transformation languages which allows one to describe how files encoded in the XML standard are to be formatted or transformed. XSL is designed to be data driven and strongly encourages the Inversion of control design pattern. There are three languages in the family:

1. XSL Transformations (XSLT): an XML language for transforming XML documents
2. XSL Formatting Objects (XSL-FO): an XML language for specifying the visual formatting of an XML document
3. the XML Path Language (XPath): a non-XML language used by XSLT, and also available for use in non-XSLT contexts, for addressing the parts of an XML document.

Source: Wikipedia

In a nutshell, XSL can be used to transform a plain XML document into a full-fledged HTML document. One thing I really like about XSL is that the processing can be done either server-side or client-side. Most modern browsers understand XSL and do all the dirty work for you, leaving your server to do other, more important, things. Not only that, but if you send the XML to the client for processing, then you have the base of your API already done.

But the best part is how modular you can make the caching. Here’s how I do it:

1. If the data is cacheable it gets saved to disk in an XML file. Queries are only done to the SQL server for this data if the cache file doesn’t exist or has expired.
2. If it’s not cacheable, insert it into the cached XML document on the fly.

Then the XSL document handles the rest. I can’t think of any simpler way to do it.

However, there are downsides (when aren’t there?):

• IE has notoriously bad support for XSL (of course).
• PHP has XSL support natively in PHP5, but PHP4 requires a PECL library (I can’t find the extension on PECL for some reason).
• More syntax to remember
• The only good documentation I’ve come across is the specification itself. W3Schools, which usually has a pretty decent overview, I found lacking.
• Most variable processing has to be done before you transform the XML. It is possible to use variables in the XSL itself, but it is very limited.
• Javascript does not work on the XML document itself, just the generated source. This means if you use AJAX to grab eg. a list of languages, you have to either do the transformation server-side or in the Javascript itself. Thankfully, Google has an excellent Javascript library to do XSL transformations! Some browsers (Mozilla is one I believe) also have built-in XSLT support in Javascript.
• Unless you do the transformation on the server-side search engine crawlers will not be able to index your site. Of course you could set it up to only transform server-side if a crawler comes.

Now I ask: why don’t more sites use XSL? I know I’ll be building most of my sites in the future with XSL, the benefits far outweigh the downsides in my opinion.

Update: I completely forgot to mention a very important downside. I bolded it in the list.