FeedMind The feed is the content is the feed 2008-01-21T11:59:42-00:00 admin http://feedme.mind-it.info/index.php meint.post@bigfoot.com tag:feedmind,2008:FeedMind Pivot Copyright (c) 2008, Authors of FeedMind Transactions, prepared statements and PHP mysqli 2008-01-21T11:59:00-00:00 2008-01-21T11:30:00-00:00 tag:feedmind,2008:FeedMind.14

While working with my good friend Arnold Consten on his new PHP application we came across some nice learning points for dealing with mysqli transactions and prepared statements. It turns out that the order of events is very specific for transactions and prepared statements to work correctly together:



  1. Make a connection with the database server

  2. Disable auto commit

  3. Initialize all prepared statements

  4. Initialize all query templates

  5. Prepare all statements

  6. Assign all bind parameters

  7. Execute

  8. Do a rollback if an error occurs in any of the situations here above

  9. If no errors commit the transaction

  10. Close the prepared statements

  11. Done



In code this boils down to the following example:



$season_ID = $_POST[frmhiddenseason_ID];
$class_ID = $_POST[frmhiddenclass_ID];

$link = mysqli_connect("localhost", "my_user", "my_password", "world");

/* check connection */
if (!$link) {
printf("Connect failed: %s\n", mysqli_connect_error());
exit();
}

mysqli_autocommit($link, FALSE);

$stmt1 = mysqli_stmt_init($link);
$stmt2 = mysqli_stmt_init($link);
$stmt3 = mysqli_stmt_init($link);

$sql1 = "INSERT INTO tbl_person (firstname, lastname) VALUES (?, ?)";
$sql2 = "INSERT INTO tbl_person_group (season_ID, class_ID, student_ID) VALUES (?,?,?)";
$sql3 = "UPDATE tbl_person SET firstname = ?, lastname = ? WHERE tbl_person.student_ID = ?";

if (mysqli_stmt_prepare($stmt1, $sql1) && mysqli_stmt_prepare($stmt2, $sql2) && mysqli_stmt_prepare($stmt3, $sql3)) {

mysqli_stmt_bind_param($stmt1, "ss", $firstname, $lastname);
mysqli_stmt_bind_param($stmt2, "ssi", $season_ID, $class_ID, $newstudent_ID);
mysqli_stmt_bind_param($stmt3, "ssi", $firstname, $lastname, $student_ID);

for ($counter = 0; $counter <= 10; $counter++) {
$frmhiddenstudent_ID = "hidden" . $counter;
$student_ID = $_POST[$frmhiddenstudent_ID];
$frmfirstname = "firstname" . $counter;
$frmlastname = "lastname" . $counter;

if ($_POST[$frmfirstname] <> "" && $_POST[$frmlastname] <> "") {
$firstname = $_POST[$frmfirstname];
$lastname = $_POST[$frmlastname];
}

if (empty($student_ID)) {
mysqli_stmt_execute($stmt1);
$newstudent_ID = mysqli_insert_id($link);
mysqli_stmt_execute($stmt2);
} else {
mysqli_stmt_execute($stmt3);
}
}
}
} else {
echo "Error";
mysqli_rollback($link);
}

mysqli_commit($link);
mysqli_stmt_close($stmt1);
mysqli_stmt_close($stmt2);
mysqli_stmt_close($stmt3);


And voila, transactions and prepared statements working nicely together making for a robust and safe database handling solution.

 admin Templates, template engines and PHP 2007-06-06T19:52:00-00:00 2007-06-05T20:33:00-00:00 tag:feedmind,2008:FeedMind.13
In the process of developing Lilliput CMS I had to think about how to do templating with PHP. There's a lot of material available regarding PHP and templating and most of it is really weird. Having had a look at the Top 25 PHP template engines I can't for the life of me understand why I would want to use something like Smarty, Savant or phptal. Obviously a lot of love and attention has been poured into these solutions but I can't escape the feeling that these template engines are recreating PHP and its innate templating function. This feeling was confirmed when reading the "Templates and template engines" article on the php patterns website. The article inspired the following train of thought:

  • Don't try to recreate PHP and its innate templating functions, it's fine as it is. This doesn't necessarily mean you should only use PHP for templating, rather that you shouldn't rebuild PHP

  • There's no sense in separating logic and content as they are intertwined and dependent on each other; focus on separating content and presentation (with the help of clean XHTML and CSS)

  • Use XHTML for templates instead of HTML 4 Strict so you can benefit from the strictness introduced by XML parsers

  • Templates are created by designers, they shouldn't need to learn a new language to accomplish their goals so the templates should use no frills XHTML

  • Because the templates use XHTML and the output format is XHTML there is no need for a template processing/transformation language, i.e. XSLT

  • There's only one standardized API for manipulating content and that's the DOM so use this for interaction with template and content

  • It should be simple to the point of sacrificing functionality to keep it simple, it won't be all things to all people

  • It needs to be extensible, you can't predict all use cases and you need to offer a way for people to introduce different behavior whilst maintaining forward compatibility


So what has this resulted in? The template needs to be valid XHTML and the designer doesn't need to learn new language constructs (so no phptal like solution). The simplest solution is to use content elements in the template that are replaced with the generated content resulting from business logic processing. Because I'm treating the XHTML templates as real XML files we need to manipulate the content via a formal API for XML, i.e. the DOM. The ground rules for this are laid out in two succinct articles "On Postel, Again" and "Are You an XML Bozo?". The replaceable elements are identified by XHTML id's, found via XPath queries and replaced via a DOM manipulation as demonstrated by the following example code.

Template code:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
<head>
<title>Lilliput CMS</title>
<meta http-equiv="content-type" content="text/html; charset=utf-8" />
<link rel="shortcut icon" href="/lilliput/favicon.ico" />
<link rel="stylesheet" href="/lilliput/template/lilliput/css/style.css" type="text/css" media="screen, projection" />
<script src="/lilliput/template/lilliput/javascript/script.js" type="text/javascript"></script>
</head>

<body>

<div id="wrapper">

<div id="header">
<p class="description">Helping you eat boiled eggs since 2006.</p>
<h1><a href="http://feedme.mind-it.info#">Lilliput CMS</a></h1>
<ul id="menu">
</ul>
</div>

<div id="content" />

<div id="footer">
<p>This text to be replaced.</p>
</div>

</div>

</body>
</html>


The PHP controller code (invoking model actions for retrieving data) that generates the content and passes it on to the view logic:

function controller_addUser() {

// invoke model logic to get the data
$results = model_addUser();
// start new DOM instance for document creation
$dom = new DomDocument('1.0', 'UTF-8');
$selectElement = $dom->createElement('select');
$selectElement = $dom->appendChild($selectElement);
$selectElement->setAttribute('id', 'fm-role');
$selectElement->setAttribute('name', 'fm-role');
$resultsCount = count($results);
for ($row = 0; $row < $resultsCount; $row++) {
$role = $results[$row]["role"];
$optionElement = $dom->createElement('option');
$optionElement = $selectElement->appendChild($optionElement);
$optionElement->setAttribute('value', $role);
$elementValue = $dom->createTextNode($role);
$elementValue = $optionElement->appendChild($elementValue);
}
// pass string data to view and get rendered XHTML structure back
$content["html"] = view_addUser($dom->saveXML($selectElement));
// return rendered XHTML structure to index.php dispatcher for inclusion in page template
return $content;
}


PHP template handling code using PHP 5 XML and DOM functions:

function processTemplate($templateFile, $content) {
// Initialize DOM document
$dom = new DomDocument('1.0', 'utf-8');
// load the template file into the DOM document
$returnValue = $dom->load($templateFile);
$xml = explode("\n", file_get_contents($templateFile));
// call the replaceDomContent function that substitutes <div id="content"/> with the generated content
replaceDomContent($dom, '//xhtml:div[@id="content"]', $content["html"]);
// call the getTitle function to retrieve the title element and replace the content with the generated title
$title = getTitle($dom);
replaceNodeContent($dom, "//xhtml:title", $title);
// export the DOM structure into an XML format
return $dom->saveXML();
}

function getTitle($dom) {
$xpath = new DOMXPath($dom);
$resultNode = $xpath->query("//h2");
$title = $resultNode->item(0)->nodeValue;
return $title;
}

function replaceDomContent($dom, $query, $content) {
$xpath = new DOMXPath($dom);
// register the xhtml namespace otherwise xpath queries will fail
$xpath->registerNamespace("xhtml", "http://www.w3.org/1999/xhtml");
$nodelist = $xpath->query($query);
$oldnode = $nodelist->item(0);
libxml_use_internal_errors(true);
$contentImport = new DOMDocument();
$returnValue = $contentImport->loadXML($content);
$xml = explode("\n", $content);
// import the converted XML content into the DOM structure
$newnode = $dom->importNode($contentImport->documentElement, true);
// Replace the old content with the new content
$oldnode->parentNode->replaceChild($newnode, $oldnode);
return $dom;
}

function replaceNodeContent($dom, $query, $content) {
$xpath = new DOMXPath($dom);
// register the xhtml namespace otherwise xpath queries will fail
$xpath->registerNamespace("xhtml", "http://www.w3.org/1999/xhtml");
$nodelistContent = $xpath->query($query);
$nodelistContent->item(0)->nodeValue = $content;
return $dom;
}
 admin Lies, damned lies and caching 2007-02-24T19:30:00-00:00 2007-02-20T22:03:00-00:00 tag:feedmind,2008:FeedMind.12 How to create a caching policy for IIS 5 using VBScript
One of the most excellent aspects of HTTP and the underpinning REST architecture is the aspect of idempotence and non-idempotence. Idempotence roughly means that some operation yields the same result whether it is done only once or several times. This behaviour forms the basis of caching because if the result is the same you can work with a copy of the result for all subsequent requests. This excellent property of the web also has some downsides as the Law of Preservation of Complexity demands that for any goodness in technology there always is a trade off in increased complexity somewhere else. In the case of caching it is determining when to cache and when not to cache.

The website that is the topic of this entry is one of the largest banking websites of Europe and it is based on IIS 5 which doesn't do a lot out-of- the -box caching wise. Problem is that if your webserver doesn't supply any information about the validity of the objects it serves you will find out fairly quickly that many parties to the conversation will cache each object quite agressively. The browser is one of these parties but also many caching proxies that are used by the target infrastructure or your ISP without you knowing it. The only way of forcing all intermediate parties to relinquish their hold on the page objects is to change the names of the objects (filenames for clarity).

A better aproach is to use cache control to specify the time-to-live (TTL) for each page object. This way the browser and all intermediate parties know how to treat the page objects. When the TTL for a given object has expired the browser (or intermediate proxy) will inquire at the target server if the object is still valid. If so the web server will respond with a 304 Not Modified instead of retransmitting the page object saving valuable bandwidth.

However as indicated the IIS 5 webserver doesn't have a lot of easily accesible cache settings available to it. There are some third party modules that you can use for this stuff but we're talking about a website with upwards of 2 million page views per day and you can't just slap in any ISAPI filter you'd like and trust that everything will turn out right (not to speak of all the test work involved when introducing an additional component in your infrastructure). One of the few components that I did use on the website (totally unrelated to the subject) was ISAPI Rewrite from Helicon Tech and it never failed us through the most extreme loads. I'm usually loath to promote vendors but these guys offer amazing value for money and offered first class support even though we paid a bargain price for their software.

Ok enough with the product talk, back to the subject of applying a caching policy to IIS. After reading up on the subject I decided to create a VBScript script for injecting the proper caching instructions in the IIS Metabase. This way the support team could apply the same policy to all machines without the risk of manual error. The script is based on various scrapings found around the web:


Option Explicit
Call Main

Sub Main
Dim RootDir, CSSDir, JSDir, ImagesDir, JavascriptDir, CSSFile, JSFile, ServerName, SiteNumber, oArgs, iArgNum,
' ServerName is default at localhost but can be changed
' via the -s "SERVERNAME" switch
ServerName = "localhost"
' SiteNumber is set at 1, the default website in IIS
' this can be changed via the -i "SITENUMBER" switch
SiteNumber = "1"
Set oArgs = WScript.Arguments
iArgNum = 0
While iArgNum < oArgs.Count
Select Case LCase(oArgs(iArgNum))
Case "-s","--ServerName":
iArgNum = iArgNum + 1
ServerName = oArgs(iArgNum)
Case "-i","--SiteNumber":
iArgNum = iArgNum + 1
SiteNumber = oArgs(iArgNum)
Case "-?","--help":
Call DisplayUsage
WScript.Quit(1)
Case Else:
WScript.Echo "Unknown argument " & oArgs(iArgNum)
Call DisplayUsage
WScript.Quit(1)
End Select
iArgNum = iArgNum + 1
Wend
WScript.Echo "ServerName: " & ServerName
WScript.Echo "SiteNumber: " & SiteNumber
WScript.Echo "Default caching policy for the entire site is caching for 2 hours (7200 seconds)"
Set RootDir = GetRootDir(ServerName, SiteNumber)
Call SetVDirCacheability(RootDir, 7200)
WScript.Echo "Caching policy for /images is caching for 1 month (2592000 seconds)"
Call GetVDirAndSetCacheability("images", ServerName, SiteNumber, 2592000)
WScript.Echo "Caching policy for /javascript is caching for 1 week (604800 seconds)"
Call GetVDirAndSetCacheability("javascript", ServerName, SiteNumber, 604800)
WScript.Echo "Caching policy for /css is caching for 1 week (604800 seconds)"
Set CSSDir = GetVDirAndSetCacheability("css", ServerName, SiteNumber, 604800)
WScript.Echo "Caching policy for /javascript is caching for 1 week (604800 seconds)"
Set JSDir = GetVDirAndSetCacheability("javascript", ServerName, SiteNumber, 604800)
WScript.Echo "/css/super.css must not be cached! Exception policy will be applied ..."
On Error Resume Next
Set CSSFile = GetObject("IIS://" & ServerName & "/w3svc/" & SiteNumber & "/root/css/super.css")
If (Err.Number <> 0) Then
WScript.Echo "/css/super.css file does not exist yet in metabase, status code " & Err.Number
Err.Clear
Set CSSFile = CSSDir.Create("IIsWebFile", "super.css")
If (Err.Number <> 0) Then
Wscript.Echo "/css/super.css object in metabase could not be created, error code " & Err.Number
Wscript.Quit
Else
WScript.Echo "/css/super.css object created in metabase and cache policy correctly applied"
End If
CSSFile.SetInfo
Else
WScript.Echo "/css/super.css object already exists in metabase"
End If
Call SetCacheability(CSSFile, 3600, "must-revalidate")
WScript.Echo "/javascript/include.js must not be cached! Exception policy will be applied ..."
On Error Resume Next
Set JSFile = GetObject("IIS://" & ServerName & "/w3svc/" & SiteNumber & "/root/javascript/include.js")
If (Err.Number <> 0) Then
WScript.Echo "/javascript/include.js file does not exist yet in metabase, status code " & Err.Number
Err.Clear
Set JSFile = JSDir.Create("IIsWebFile", "include.js")
If (Err.Number <> 0) Then
Wscript.Echo "/javascript/include.js object in metabase could not be created, error code " & Err.Number
Wscript.Quit
Else
WScript.Echo "/javascript/include.js object created in metabase and cache policy correctly applied"
End If
JSFile.SetInfo
Else
WScript.Echo "/javascript/include.js object already exists in metabase"
End If
Call SetCacheability(JSFile, 3600, "must-revalidate")
WScript.Echo ""
WScript.Echo ""
Call SetHTMLCharSet(ServerName, SiteNumber)
End Sub

Function GetRootDir(ServerName, SiteNumber)
Dim RootDir
On Error Resume Next
Set RootDir = GetObject("IIS://" & ServerName & "/w3svc/" & SiteNumber & "/root")
If (Err.Number <> 0) Then
WScript.Echo "Root dir does not exist for site index " & SiteNumber & ", error code " & Err.Number
WScript.Quit
Else
WScript.Echo "Root dir found for site index " & SiteNumber
End If
Set GetRootDir = RootDir
End Function

Function SetVDirCacheability(IISObject, CacheTimeInSeconds)
Call SetCacheability(IISObject, CacheTimeInSeconds, "must-revalidate")
End Function

Function SetCacheability(IISObject, CacheTimeInSeconds, CacheDirective)
On Error Resume Next
IISObject.CacheControlCustom = "max-age=" & CacheTimeInSeconds & "," & CacheDirective
If (Err.Number <> 0) Then
WScript.Echo "CacheControlCustom property set failed, error code: " & Err.Number
WScript.Quit
Else
WScript.Echo "CacheControlCustom property set: max-age=" & CacheTimeInSeconds & "," & CacheDirective
End If
IISObject.SetInfo
End Function

Function GetVDirEvenIfNotExists(DirName, ServerName, SiteNumber)
Dim Dir
Dim RootDir
On Error Resume Next
Set Dir = GetObject("IIS://" & ServerName & "/w3svc/" & SiteNumber & "/root/" & DirName)
If (Err.Number <> 0) Then
WScript.Echo "VDir " & DirName & " does not exist yet"
Set RootDir = GetRootDir(ServerName, SiteNumber)
Set Dir = RootDir.Create("IIsWebVirtualDir", DirName)
If (Err.Number <> 0) Then
WScript.Echo "VDir " & DirName & " could not be created, error code " & Err.Number
WScript.Quit
Else
WScript.Echo "VDir " & DirName & " created"
End If
Dir.SetInfo
Else
WScript.Echo "VDir " & DirName & " already exists"
End If
Set GetVDirEvenIfNotExists = Dir
End Function

Function GetVDirAndSetCacheability(DirName, ServerName, SiteNumber, CacheTimeInSeconds)
Dim Dir
Set Dir = GetVDirEvenIfNotExists(DirName, ServerName, SiteNumber)
Call SetVDirCacheability(Dir, CacheTimeInSeconds)
Set GetVDirAndSetCacheability = Dir
End Function

Sub SetHTMLCharSet(ServerName, SiteNumber)
Dim strExtension, strMimeType
strExtension = ".htm"
strMimeType = "text/html; charset=utf-8"
AddTypeToIIS ServerName, strExtension, strMimeType
strExtension = ".html"
strMimeType = "text/html; charset=utf-8"
AddTypeToIIS ServerName, strExtension, strMimeType
End Sub

Sub AddTypeToIIS(ServerName, varMimeExt, varMimeTyp)
Dim boolFound, intCount, intMimeMap, objMimeMap, varMimeMap, i, MMItem, aMimeMapNew()
Const ADS_PROPERTY_UPDATE = 2
' create the ADSI object & current MIME map at that path
Set objMimeMap = GetObject("IIS://" & ServerName & "/MimeMap")
varMimeMap = objMimeMap.GetEx("MimeMap")
'Delete a mapping by copying to a new map array.
i = 0
For Each MMItem in varMimeMap
If MMItem.Extension <> varMimeExt Then
Redim Preserve aMimeMapNew(i)
Set aMimeMapNew(i) = CreateObject("MimeMap")
aMimeMapNew(i).Extension = MMItem.Extension
aMimeMapNew(i).MimeType = MMItem.MimeType
i = i + 1
Else
WScript.Echo "Mime type " & MMItem.Extension & " excluded"
End If
Next
objMimeMap.PutEx ADS_PROPERTY_UPDATE, "MimeMap", aMimeMapNew
objMimeMap.SetInfo
' get the MIME map count
intMimeMap = UBound(aMimeMapNew) + 1
' if no extension information is found, create the new mapping
ReDim Preserve aMimeMapNew(intMimeMap)
Set aMimeMapNew(intMimeMap) = CreateObject("MimeMap")
aMimeMapNew(intMimeMap).Extension = varMimeExt
' store the new information in the MIME map
aMimeMapNew(intMimeMap).MimeType = varMimeTyp
objMimeMap.PutEx ADS_PROPERTY_UPDATE, "MimeMap", aMimeMapNew
objMimeMap.SetInfo
End Sub

Sub DisplayUsage
WScript.Echo "Usage: iis_caching_policy.vbs <-s|--ServerName ""SERVERNAME""> <-i|--SiteNumber ""SITENUMBER""> [-?|--Help]"
WScript.Echo ""
WScript.Echo "SERVERNAME Optional - The name of the server, default is localhost"
WScript.Echo "SITENUMBER Optional - The sitenumber of the affected site, default is 1"
WScript.Echo ""
WScript.Echo "Example: iis_caching_policy.vbs -s tracker -i 3"
WScript.Quit (1)
End Sub


If you look closely at the script (not too close, it's not a major work of art) you can see there's an exception for two files: super.css and include.js. The reason for this is that all pages are published as static pages from a Content Management System. Static pages deliver the optimum trade off in speed versus processing power. The problem with static pages, idempotent behavior and caching however is that if you do your work very well hardly any updates will get over to the customer unless you change filenames. This is rather unwieldy with a large website as this would require continuous republication of the website when you want to deliver new javascript or css files. The trick I applied was to have a "super" CSS file that includes all other CSS files. The super CSS file has a very limited time span (1 hour), as demonstrated by the VBScript, so you can update the included CSS files by changing their filenames and the client will notice the updated CSS files after the super CSS file has expired after one hour without having to republish all web pages. The same trick applies to the Javascript files.

Oh, by the way this stuff is a breeze to setup in Apache but sometimes you have to work with the stuff at hand.
admin PHP, DOM and XPath query 2007-02-24T19:42:00-00:00 2007-01-28T15:56:00-00:00 tag:feedmind,2008:FeedMind.11 How to use PHP XPath queries with XHTML
My work for the Lilliput CMS has lead to some interesting new findings about PHP 5's new DOM functions, particularly the XPath part of it. Whilst working on the templating structure for Lilliput I couldn't get the DOM XPath queries to work on the file at hand, a normal XHTML 1.0 Strict document. With an external tool called XPath Explorer (XPE) every query evaluated correctly but as soon as I tried the same XPath expression in PHP it failed. After searching long and hard I came across a code snippet that contained the solution namely to explicitly declare the xhtml namespace for the DOM document you're working on:


<?php
$templateFile = 'template/lilliput/index.xhtml';
$dom = new DomDocument('1.0', 'utf-8');
$returnValue = $dom->load($templateFile);
$xpath = new DOMXPath($dom);
$xpath->registerNamespace("xhtml", "http://www.w3.org/1999/xhtml");
$nodelist = $xpath->query('//xhtml:div[@id="content"]');
$noderesult = $nodelist->item(0);
?>


After this no problems any more but very strange that this isn't mentioned in the PHP DOM documentation anywhere. Even stranger that my user contributed note on this on the XPath query function manual page doesn't seem to have been accepted. Hopefully somebody will gain some help from this blog entry.
admin Atom feeds, client-side XSLT and crappy browsers 2007-02-24T20:29:00-00:00 2007-01-09T14:34:00-00:00 tag:feedmind,2008:FeedMind.9 Automatic recognition of feeds and subsequent applicability of browser XSL stylesheets can be avoided by taking up the first 512 bytes with comments
After providing feedback on an article on 24 ways called "Making XML Beautiful Again: Introducing Client-Side XSL" that never got published I decided to write a short entry that explains how this feedsite escapes the feed sniffing and subsequent browser applied default XSLT stylesheet that has been implemented by Safari 2, FireFox 2 and Internet Explorer 7. As soon as these browsers see content they perceive as a feed they ignore all instructions like an XSL style sheet inclusion and render the contents to their liking instead of the authors liking.

Luckily enough the method these browsers employ for feed sniffing is crude enough to trick them into believing they're not dealing with a genuine feed by eating up the first 512 bytes of the feed with unrecognizable crud. So basically the only thing you need to do is insert a comment before the feed element that is larger than 512 bytes. An excerpt from the source code of this page:

<?xml version="1.0" encoding="utf-8"?>
<?xml-stylesheet href="atom" type="text/xsl"?>
<!-- This is a comment that has been inserted because of the arrogance of IE7 and FireFox 2 developers that have decided that they don't need to honour a xml stylesheet instruction. Luckily the designers of these browsers use very brittle sniffing techniques that can be overridden by consuming the first 512 bytes of an xml file. This comment provides these essential 512 bytes of crud and destroys the nice simplicity and cleanliness of my Atom feed. This is a comment that has been inserted because of the arrogance of IE7 and FireFox 2 developers that have decided that they don't need to honour a xml stylesheet instruction. Luckily the designers of these browsers use very brittle sniffing techniques that can be overridden by consuming the first 512 bytes of an xml file. This comment provides these essential 512 bytes of crud and destroys the nice simplicity and cleanliness of my Atom feed. This is a comment that has been inserted because of the arrogance of IE7 and FireFox 2 developers that have decided that they don't need to honour a xml stylesheet instruction. Luckily the designers of these browsers use very brittle sniffing techniques that can be overridden by consuming the first 512 bytes of an xml file. This comment provides these essential 512 bytes of crud and destroys the nice simplicity and cleanliness of my Atom feed. -->
<feed
xmlns="http://www.w3.org/2005/Atom"
xmlns:xforms="http://www.w3.org/2002/xforms"
xml:lang="e>
<title>FeedMind</title>


And presto you can apply your own client-side XSLT to your hearts content.
admin Building this site 2007-03-02T20:17:00-00:00 2006-02-14T10:33:00-00:00 tag:feedmind,2008:FeedMind.10 A description of the techniques used to build this site
This blog uses a novel approach (I think) in that it is entirely Atom 1.0 based. There is no underlying (X)HTML, everything is Atom (with a hint of XSL). I came to this approach after I figured out that it is silly to serve the same content in multiple formats when one format suffices. Modern browser are perfectly capable of executing XML/XSL that allow for the transformation of the Atom 1.0 feed into XHTML. There's some nice stuff going, let's dig into the details (hey I'm a technologist at heart so why not busy myself with the stuff I love):

The main engine is Pivot, http://www.pivotlog.net. I like Pivot more and more, it doesn't get in the way and I haven't had to tweak a single line of code to get where I'm at right now which is frankly amazing to me and a tribute to the design of Pivot.

Pivot creates an Atom output file, index.xml (the filename is configurable in Pivot).

This file is configured as default document via an Apache .htaccess instruction:

DirectoryIndex index.xml

This means your browser gets XML (Atom) served directly when you access http://feedme.mind-it.info/ instead of HTML.

Pivot has several templates available to apply to content output, one of them being an Atom 1.0 template. Due to Pivot's ingenious templating structure I was able to add an XSL stylesheet to the XML output without a problem:

<?xml-stylesheet type="text/xsl" href="atom"?>

The XSL stylesheet is called atom, I use Apache content negotiation via Multiviews to deliver the correct XSL stylesheet with either application/xhtml+xml or text/html (Internet Explorer) as media format:

Options +Multiviews
AddType application/xhtml+xml;qs=0.9 .xsl+xhtml
AddType text/html;qs=0.9 .xsl
AddType application/xhtml+xml .xsl+xhtml
AddType text/html .xsl+html

The code above basically selects the right atom XSL file based on the capabilities of the browser. If the browser is application/xhtml+xml capable and prefers this media type (via the qs quality factor) the atom.xsl+xhtml file will be served. If on the other hand the browser isn't willing or capable (think Internet Explorer) it will be served the atom.xsl+html file.

atom.xsl+html:

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:dc="http://purl.org/dc/elements/1.1/"
xmlns:atom="http://www.w3.org/2005/Atom"
xmlns:xhtml="http://www.w3.org/1999/xhtml"
xmlns="http://www.w3.org/1999/xhtml">

<xsl:output encoding="utf-8" indent="yes" method="xml"
omit-xml-declaration="yes"
media-type="text/html"
doctype-public="-//W3C//DTD XHTML 1.0 Strict//EN"
doctype-system="DTD/xhtml1-strict.dtd"
cdata-section-elements="script style"/>

<xsl:include href="main.xml" />
</xsl:stylesheet>

atom.xsl+xhtml:

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:dc="http://purl.org/dc/elements/1.1/"
xmlns:atom="http://www.w3.org/2005/Atom"
xmlns:xhtml="http://www.w3.org/1999/xhtml"
xmlns="http://www.w3.org/1999/xhtml">

<xsl:output encoding="utf-8" indent="yes" method="xml"
omit-xml-declaration="no"
media-type="application/xhtml+xml"
doctype-public="-//W3C//DTD XHTML 1.0 Strict//EN"
doctype-system="DTD/xhtml1-strict.dtd"
cdata-section-elements="script style"/>

<xsl:include href="main.xml" />
</xsl:stylesheet>

The XSL file itself uses an xsl:include to import the main part of the XSL transformation so I can have two relatively small XSL files to support the content negotiation (atom.xsl+html for text/html and atom.xsl+xhtml for application/xhtml+xml).

All looked well but somehow the HTML formatting wasn't getting through in Mozilla FireFox. No problems in Internet Explorer though, strange ... This is the kind of conundrum that can take all day to solve and it did (take a whole day). On the positive side I learned a lot about XSL, CDATA, namespaces and local names but man what an annoying problem. It turns out that Internet Explorer is quite forgiving but Firefox is more strict in copying portions of XML in a different namespace in the result XML tree. The source document is in the Atom 1.0 namespace (http://www.w3.org/2005/Atom) whilst the result document is in the XHTML namespace (http://www.w3.org/1999/xhtml). Firefox will not allow you to do this (as per XSL specification). The solution took ages to find with various sidesteps involving trying to replace the Atom namespace via XSL but the solution turned out to be pretty simple. I just have to add a <div> element with the XHTML namespace to the content element and all is well.

<content type="xhtml" xml:lang="en" xml:base="http://feedme.mind-it.info/pivot/entry.php?id=8">
<div xmlns="http://www.w3.org/1999/xhtml">
..
</div>
</content>


Well that's basically it. I need to change and tweak a lot but the technique described here is basically what drives this feed/site.

BTW if you're wondering about the layout of the site, I'm not much of a designer so I used a ready made layout from Andreas Viklund. The photo at the top is mine though, I shot it in 2003 in Gyongju (South-Korea).
admin Welcome to FeedMind 2006-09-06T15:20:00-00:00 2006-02-14T08:51:00-00:00 tag:feedmind,2008:FeedMind.7 Starting entry for feedmind explaining the content of the blog
Welcome to FeedMind, my personal blogging space and ongoing experiment in web technology. I've been thinking about doing a blog for years, started several times but never finished anything. This time it looks like I'm going to succeed :-) I'll be mainly blogging about ICT Architecture, Information Security and Web Technology in the broadest sense. Once in a while something personal may crop up, it can't be helped.

I'm quite a practical guy although I do like the saying that "there's nothing more practical than a good theory". There's a lot of opinion floating around that's propagated by people who obviously haven't carried any large projects in the real world. There's a limit to the amount of new technology you can cram into any project and believe you me that five year old technology still counts as new. I hope to add a voice to the chorus that tries to explain that there's more than one way to do it (although certain problems can have only a limited amount of correct solutions). You see, I'm already being reasonable on the first posting, it's stronger than myself.

Anyway, hope you like the blog.

Cheers,

Meint
M.E. Post