I am just about to rebuild my blog to try and reclaim a bit of my digital life, before doing that I have switch on Matthias Pfefferle WordPress plug-in for WebMentions to see how it works.

UPDATED POST: Tues 12 Mar 2013

We have just hit a bit of an issue with AppCache whilst we were deploying a new version of a client site. It’s not really a bug, but more a lack of clarity in the current documentation and different implementations in the browsers.

It has taken me sometime to understand how the NETWORK: section of the AppCache actually works. In the end, I had to build a series of AppCache tests to figure it out.

The story

We setup the NETWORK: section of the AppCache to point at a rest API

NETWORK:
//example.com/api/*

# This code is an incorrect use of AppCache

Breaking AppCache

As we deployed our site we wanted to run the API that is on another domain under SSL. So we changed the URL in the NETWORK: section so it started with https and added the certificate to the site. i.e.

NETWORK:
https//example.com/api/*

# This code is an incorrect use of AppCache

At this point Chrome stopped making API requests, we were only initially testing with Chrome.

First mistake – putting the * wildcard in the wrong place

Our first mistake is that we wrongly added the * wildcard to the end of the URL. Each entry in the NETWORK: section can be one of three types. These entries are usually added as a new line directly under the NETWORK: section header. The entry types are:

• * wildcard on its own
• relative or absolute URL
• URL “Prefix match”

Examples of the correct use of AppCache NETWORK: section

NETWORK:
/data/api/
https//example.com/api/
*

“Prefix match” URL

A “Prefix match” is a strange concept – it’s a URL that is used as a “starting with” matching pattern. If your API has many endpoints but they all live in the path http://example.com/api/ then that’s all you need to add to the NETWORK: section. The * wildcard can only be used on its own and means any URL.

Second mistake – URLs should have the same protocol and domain as the manifest

There are other rules that effect the use of URLs in the NETWORK: section. All URLs have to use the same protocol scheme i.e. http or https and be from the same domain as the manifest.

Browser implementations of these rules do differ, Firefox is strict and insists on the same domain, where as other browsers only insist on the same protocol scheme. See the test examples I have built to demonstrate this.

In effect, that means to get good support across the major browsers you can only use URLs in the NETWORK: section if they are to the same domain as the manifest.

The fix is to use the * wildcard and not URLs

The vast majority of sites sidestep the complexities of URLs, by just applying the * wildcard on its own i.e.

NETWORK:
*

This will work with the manifest on one scheme (http) and the API on another (https). The wildcard does not have the same rules as URLs.

You have to ask why the hell the authors of the specification added all this complexity if all that happens is that everyone applies the * wildcard.

Thanks to Jake Archibald for some pointers to the answers as I waded my way through this.

I have just released a brand new microformats 2 parser for node.js. You maybe thinking microformats are so 2006, but this is new. Hear me out…

Demo API /> http://microformat2-node.jit.su/

Try the API with: /> http://the-pastry-box-project.net/ /> http://microformats.org/

New life in the semantic web

A lot has changed in the last couple of years; the search engines have started to use semantic mark-up to improve their listings. Google’s rich snippets feature has created a secret army of SEO people who are quietly marking up big parts of the web with semantic data. Not that there are not already billions of microformats on the web.

HTML5 created a third standard of semantic web mark-up to add to the mix of RDFa and microformats. Then the search engines clubbed together and brought us schema.org. After a few catfights between the standards supporter clubs, these events have brought us a small rebirth of the semantic web.

microformats 2

The microformats community has revisited it’s standard and come up with “microformats version 2”. At first, I thought why! I don’t like change unless it gives me something worthwhile. After reviewing the work, I think the wholesale change to a new version of microformats is worthwhile because:

1. The authoring patterns have been simplified even more and they are based on real life use cases e.g.: Glenn Jones is a valid microformat

/>

2. microformats 2 addresses one of the biggest problems in maintaining microformats in real sites. The class names are now prefixed i.e. class=”fn” is now class=”p-name”. The prefixes like “h-*” and “p-*” tells you a class is a microformat property and helps make sure classes are not moved or deleted by mistake

/>

3. Like microdata, microformats 2 now has a full specification for a JSON API. This is important as it means the parsers should now have the same output and also browsers could implement this API.

New parser and test suite

Most importantly for me I wanted to help move forward microformats, I liked the fact that the API design aligned microformats 2 a little closer to microdata and RDFa. So I have invested a couple of months of my time to building a brand new JavaScript parsing engine and a comprehensive test suite.

microformat-node GitHub https://github.com/glennjones/microformat-node /> Test Suite GitHub https://github.com/microformats/tests

I have just open sourced a new version of microformat-node using this parsing engine. Soon I will create a browser compatible version of the engine and update the microformat-shiv library which powers browser plug-ins etc.

The test suite took a long time to develop, but should provide an excellent starting point for anyone else who wants to develop a new microformats 2 parser. I know Barnaby Walters has already started working with it for his php-mf2 parser.

I hope this work will help microformats and the concept of the semantic web move forward another little step. Enjoy

Last weekend I attended NodeCopter Brighton, a day of hacking AR-Drone’s and node.js. I wanted to control the drone by hand jestures using the Kinect’s motion detection abilities.

Links to the high-res versions (.mov, .mp4 or .ogv) of the video

Hackdays are funny, sometimes everything comes together, other times small things just trip you up. Unfortunately Saturday was a day when nothing seemed to work for me, mainly because I made the mistake of loading the wrong version of a USB driver.

On the upside that day I bumped into Aral getting coffee at Taylor St who pointed me to a project he did using Kinect with processing.

So after a couple of hours of hacking after the event, I could wave my hands and fly a drone. Once I had the right USB driver installed.

Thanks to everyone who made the day possible, I had a great time. I am glad with others, Madgex was able to sponsor the event.

You can download the project from github kinect-drone, enjoy

I have just uploaded a new version of microformat-node. The parser now takes between 30-40 milliseconds to parse an average page, about 8 times the speed of the last version.

Features of new version

• About 8x faster at parsing
• Will now load onto Windows based hosting solutions correctly
• Inbuilt cache system, which can be customised
• Upgraded logging and trace options
• Upgraded unit test system
• Added support for JavaScript promise

Example: http://microformat-node.jit.su/ /> Code: https://github.com/glennjones/microformat-node

I have changed how the method calls work so if you are using the last version you may have to update your code. The parse methods parseHtml and parseUrl now follow the standard pattern used in node.js and return an error and data object rather than just the data object.

with URL

var microformat = require("microformat-node");

microformat.parseUrl('http://glennjones.net/about', function(err, data){
    // do something with data
});

or with raw html

var microformat = require('microformat-node');

var html = '
Glenn Jones
';
microformat.parseHtml(html, function(err, data){
    // do something with data
});

using a promise

var microformat = require("microformat-node");

microformat.parseUrl('http://glennjones.net/about').then( function(err, data){
    // do something with data
}));

I have built a node.js microformats parser, it is based on my previous javascript parsing code. It has been packaged up so you can easily be add to your projects using npm.

Source code: https://github.com/glennjones/microformat-node /> Test server : http://microformat-node.jit.su

Install

npm install microformat-node

or

git clone http://github.com/glennjones/microformat-node.git
cd microformat-node
npm link

Use

with URL

var shiv = require("microformat-node");

shiv.parseUrl('http://glennjones.net/about', {}, function(data){
    // do something with data
});

or with raw html

var shiv = require('microformat-node');

var html = '
Glenn Jones
';
shiv.parseHtml(html, {}, function(data){
    // do something with data
});

with URL for a single format

var shiv = require("microformat-node");

shiv.parseUrl('http://glennjones.net/about', {'format': 'XFN'}, function(data){
    // do something with data
});

Supported formats

Currently microformat-node supports the following formats: /> hCard, XFN, hReview, hCalendar, hAtom, hResume, geo, adr and tag. Its important to use the right case when specifying the format query string parameter.

Response

This will return JSON. This is example of two geo microformats found in a page.

{
    "microformats": {
        "geo": [{
            "latitude": 37.77,
            "longitude": -122.41
        }, {
            "latitude": 37.77,
            "longitude": -122.41
        }]
    },
    "parser-information": {
        "name": "Microformat Shiv",
        "version": "0.2.4",
        "page-title": "geo 1 - extracting singular and paired values test",
        "time": "-140ms",
        "page-http-status": 200,
        "page-url": "http://ufxtract.com/testsuite/geo/geo1.htm"
    }
}

Querying demo server

Start the server binary:

$ bin/microformat-node

Then visit the server URL

http://localhost:8888/

Using the server API

You need to provide the url of the web page and the format(s) you wish to parse as a single value or a comma delimited list:

GET http://localhost:8888/?url=http%3A%2F%2Fufxtract.com%2Ftestsuite%2Fhcard%2Fhcard1.htm&format=hCard

You can also use the hash # fragment element of a url to target only part of a HTML page. The hash is used to target the HTML element with the same id.

Viewing the unit tests

The module inculdes a page which runs the ufxtract microfomats unit test suite.

http://localhost:8888/unit-tests/

Notes for Windows install

microformat-node using a module called ‘jsdom’ which in turn uses ‘contextify’ that requires native code build.

There are a couple of things you normally need to do to compile node code on Windows.

1. Install python 2.6 or 2.7, as the build scripts use it
2. Run npm inside a Visual Studio shell, so for me, Start->Programs->Microsoft Visual Studio 2010->Visual Studio Tools->Visual Studio Command Prompt

If you have the standard release of node it will probably be x86 rather than x64, for x64 there is a different Visual Studio shell but usally in same place.

From this Friday I am looking for new things to do. I have pulled out of working full time at the company I co-founded. I will remain a director and major shareholder, and no Madgex is not in trouble in fact the opposite, it has just had its most profitable quarter in its history. After helping restructure it over the last year I have the opportunity to do other things.

This has left me in the lucky position of being able to follow my passions. I want to try to take the product research and design I have done commercially for years and mix it with my interests in open web and standards development.

In the next few months I want to research and build projects in a number of areas:

• Web Intents/Activities
• Personnel data stores using services like Dropbox
• Possibility of semantic data reuse
• Mobile web apps – the right way

I am sure within a few months I will want to work with teams again as I always want to design and build products that impact people’s lives, that usually means lots of calibrations, but at first I want some time to open my mind to new people and ideas.

No sitting on beaches for me. Watch this space I am about to turn up the volume…

Last Friday I went to DevUp 2012 in Barcelona. The event focused on HTML5, but interestingly for me it mixed two different development communities. As well as web developers there is a whole world of games developers who are embracing HTML5 or more precisely Canvas. Darius Kazemi from bocoup did a talk which made a side-by-side comparison of the web and games development culture. As a games developer in a JavaScript company he had some nice insights.

I missed Javier Usobiaga talk on Responsive Web Design, which is a shame, but managed to go to the session by Ibon Tolosana on CocoonJS. It takes HTML5 canvas based games and boosts their performance by using an OpenGL ES execution environment. Through the day a recurring theme seemed to be that the current performance of Canvas on phones is just under what the gaming community are looking for. Although like petrol-heads I feel they will always want just a few extra frames per a second. The best example of this was Miguel Ángel Pastor’s talk on cross compiling JavaScript from C++. Not an approach I would take, but interesting.

I hope people found my talk “Beyond the page” on API’s of interest. The Web Intents demo did not work, although I am in good company as Paul Kinlan had the same trouble when he visited Barcelona. Maybe adding that one last demo at 1am the night before was not a good idea! Next time I am going to have backup screencasts.

The PeopleStore HTML5 app I showed on the day is unfortunately not online, but the codebits area of my site does have demos/code of some of the API’s it uses.

• Building a virtual file and creating a download link
• Creating a virtual file that can be dragged off the browser
• Copy and paste data between pages
• Custom protocol handlers

Sorry the video does not show the demo’s there is an earlier screencast of some of these demo’s from a previous blog post.

I would like to thank Ideateca for inviting me to speak and putting on such a good event, the live translation services and high quality video which was streamed live added to the events success.