If you have a list of dicts in Python like this:

aXRlbXMgPSBbeyJpZCI6MSwgIm5hbWUiOiAiUmFzbXVzIn0sIHsiaWQiOiAyLCAibmFtZSI6ICJSaWNrIn1d

…and want to check if there are any dict items with an id of a specific value (e.g. 2) I first came up with this:

MiBpbiBtYXAobGFtYmRhIHg6IHhbJ2lkJ10sIGl0ZW1zKQ==

The downside is that it will loop all items which may be inefficient for larger lists. Niklas eventually pointed me at Python’s any() function which I managed to miss while googling for other ways. Thus, a nicer version is:

YW55KGl0ZW1bJ2lkJ10gPT0gMiBmb3IgaXRlbSBpbiBpdGVtcyk=

Handy for checking stuff in Django object collections.

2. YUI Grids looks difficult but is easy

I decided to scrap the YAML based layout of a site I made a while ago when I discovered the licensing agreement (requires backlinks for the free version). I turned to YUI Grids which I had a look at a long time ago, but didn’t use because it looked too complex. Maybe it is just the layout of the YUI grids website (massive amounts of text), but it felt complicated at a first glance.

Coming back to YUI Grids this time I skipped the documentation and went straight for the examples. It is simple as soon as you understand grids (yui-g) and units (yui-u). I managed to get the basic layout going in an hour. Thank you YUI team!

3. Django’s template language is heavily opinionated

They really, really don’t want you to write anything but pure template code in there. Which is good, I guess. I only tried doing some basic addition. Sorry.

Like many before me, I was searching (unsuccessfully) for a decent twitter client. There are many, but most seem to be ad sponsored or based on a rather hefty framework like AIR (which by now, I guess, has been silently installed on my computer anyhow).

Custom apps have major implications for usability so I decided to roll my own. I wanted to try out Fluid, the Prism-like app to contain web apps in their own process/window, to see if it is possible to build a complete open source ad-free twitter client in a single web page only using javascript and HTML.

So, I cuiled for a jQuery twitter plugin but had to google it to find it. Some minor modifications to the code by the fine folks at SeaOfClouds and adding a method to post new status messages gave this native-looking OS X twitter client (HUD-style to the left, default style to the right and HUD avatars style below):

Thank’s to the twitter json api it was trivial to query my own friend feed and display it in Safari. Then, I used Fluid to create a self contained OSX app that displays my static HTML page. Googling a nice application icon makes it much better-looking in the taskbar. I decided to call it “Twoot”. Twoot consumes little memory and plays nice with embedded URLs (they open in a new Firefox tab).

Unfortunately, Fluid does not allow you to distribute the created app so you will have to roll your own by:

1. Download and install Fluid.
2. Create a folder called “twoot” in your home directory.
3. Download the twoot html, js and css files from github and place in the twoot folder.
4. Edit twoot.js and set your twitter username and password. (Enter credentials in the basic auth form when launching app the first time).
5. Open Fluid and create a new app by pointing to the twoot.htm file (e.g. file:///users/you/twoot/twoot.htm) and set a nice icon.
6. Save the app as “Twoot”.
7. Your new twitter client is ready! Run it and resize as required, set the window to floating, kill tabs etc. Change the twoot.css and html file to customize it further.

Simple API:s are wonderful for usability!

• Designed for humans first, machines second
• Modularity / embeddability
• Enables and encourages decentralized development, content, services
• A design principle for formats
• Adapted to current behaviors and usage patterns
• Highly correlated with semantic XHTML

I am new to RDF and the semantic web (but have used microformats in previous web projects) but to me the advantages of RDF and RDFa (the “sprinkling” framework) are clear. Microformats may work for a limited set of use cases but I have not yet understood how to use microformats efficiently for the bulk of what I need. However, it is great that a lot of development is going on in the area of embedding machine readable data in documents. Without microformats the pace would probably have been much slower.

Here are my thoughts on the items that James mention:

Designed for humans first, machines second: For me the HTML document that carries the information is for humans. With it we apply styling and markup to allow humans (and their assistive devices) to understand the content. The embedding of data is for machines primarily. Although advanced editors may be great at editing HTML, the fact is that most users are not.

Modularity / embeddability: Embeddability is of course necessary. The problem is that the current versions of (X)HTML were not designed for embedding data. This means that Microformats have to rely on the attributes and elements available of which none were primarily designed for stuffing machine readable information in. RDFa, on the other hand, is making rapid progress. You can use XHTML 1.1 with RDFa right now and validate it with the W3C validator.

Enables and encourages decentralized development, content, services: I am not sure I understand this one, at least not for the development of vocabularies. Microformats encourages a centralized way of storing vocabularies on their web site in a format that isn’t machine readable. The power of RDF is that vocabularies can be stored anywhere in a machine readable way. The world is big and the web has been built to support interaction in a decentralised way. Development of a vocabulary is a local thing for me.

A design principle for formats: See above. Why have a design principle for all? Everyone has different needs and resources and I would prefer to adopt the vocabulary design process to each business case. The Microformats.org website lists design patterns to use when sprinkling a document with embedded data. Instead of calling them design patterns you could say “seeing how far we can go in interpreting the current HTML specification”.

Adapted to current behaviors and usage patterns: Sure, if you limit yourself to a few HTML-adept bloggers. I would venture to guess that there are more people publishing information on the web that know little to nothing about markup than people who do. And they shouldn’t need to. Peple working with information need tools. Tools should help out with the actual markup and embedding of data.

Highly correlated with semantic XHTML: And this is good. But it contradicts the previous statement. Current behaviour is to not use semantic XHTML. It is only a limited number of websites that use valid markup. Both RDFa and Microformats will hopefully help in raising awareness of semantic markup.

What do you think?

SimpleCrawler is a Ruby gem that covers basic web crawling needs. Coupled with Raakt and Ruport it can be used to create a basic accessibility report for a website.

A minimal example:

require ‘simplecrawler’

# Set up a new crawler
sc = SimpleCrawler::Crawler.new(“http://www.peterkrantz.com/”)

sc.crawl { |document|
# output the crawled uri
puts document.uri
}

For more details and examples see the SimpleCrawler wiki.

• There is no doctype declaration. Not that it would have mattered anyway…
• The markup starts out nicely with divs and spans and then freaks out with some classic table layout. I though that went away in the nineties…
• Inline styles are used all over the place.
• Headings start at level 5. And continues to level 4…
• Images are missing an alt attribute.

This contributes to making MySpace an inaccessible mess. What does it prove? That you can be successful with a crappy site? Maybe the laugh is on me.

A brief look at the HTML source gives:

…which safari doesn’t follow. Interestingly, search engines won’t be following that either. What happened to the plain old HTTP redirect header? There can’t be a single programming language for the web today that doesn’t support output of HTTP headers. Or are there still web developers that don’t know about HTTP? Apparently so.