RDF Gallery

Background

I was playing around with ideas how to create a neat little gallery to my homepage. I don't like dynamic content so i started thinking about how i could generate a gallery without using dynamic content, but still avoiding the need to create the html around the images. My current homepages consist of XHTML files that are passed through XSLT stylesheet which adds the layout and outputs XHTML. But with static html galleries it would be pretty painful to pass all those files through the filter (let alone rename them all to .xml and check them for xml validity). I've also been interested in all sorts of RDF based technologies, it's pretty interesting how much of the current internet could be simplified just by using RDF to describe the data that is out there. Google could index the images without having to guess what it's related to, registering to different services would be simpler when the services could fetch the needed information from a FoaF file and such.

This lead me to a idea that might turn out useful for even more people than me. A gallery engine that isn't dependent of direct filesystem access or databases. A gallery that could represent images for remote sites with complete descriptions. A gallery that would be simple to install, or you could avoid installing it at all.

After a bit of thinking, the gallery splits in to multiple pieces quite nicely. My intention here is to describe those pieces in hope someone would someday implement those (i'm currently hoping that someone would be me, but i try and keep my feet in the ground and not to hope too much ;)

Gallerizer

The main part of the gallery would be the gallerizer, which would actually take care of fetching the rdf and displaying the gallery itself. This could be done with a simple XSLT stylesheet. But i want to add some intelligence to the app, like resizing local images and thumbnails. This might actually be the easy part.

Gallerizer should ask Thumbnailer wether the gallery is thumbnailable and what kind of thumbnails the thumbnailer creates so that it can alter its output to match the thumbnails.

Thumbnailer

Simple application that generates and fetches thumbnails that are requested by gallerizer. Thumbnailer should integrate tightly with Cacher to maintain a cache of the generated thumbnails.

Generator

This is a bit harder. For this thing to work, we need a generator component. This is to allow the non computer savvy people to generate the needed rdf too. The generator could allow the user to upload the files to the server too, but basic idea would be to make the generator generate RDF descriptions for images offsite.

Indexer

Ofcourse, now that we have gotten to a good start, and we have a gallerizer that allows one to display galleries from different sites, it would be interesting to index those sites and allow access to those sites later on too. This would most likely consist of a single RDF file that lists all other RDF files and includes basic descriptions of those files.

Cacher

Cacher component comes in handy when it comes to thumbnails and possible other resized images. It is also needed to cache the RDF files fetched from other sites to allow the gallerizer to work faster. This is ofcourse an optional component, and it should be built in such a way that it keeps it's cache clean (after outputting the data requested, checks for cache age and cleans up behind) Ofcourse cacher needs to be aware what to cache, one should cache offsite images and such, but just the things that get generated.

Cacher should have an rdf index (why not?) that contains list of files generated, their locations and creation date. This way the requesting application could tell cacher wether the data needs to be updated or not.

Announcer

Now, we have all our basic components, why not add something interesting too. Hook up a gallery with jabber and pubsub, and what do you have? A distributed gallery network. When a gallery sees a new gallery that people consider interesting, it could announce it to other galleries. It would also be interesting to create somesort of discributed scoring system for images. This is something i havent yet explored in such depth to see what could be implemented and what is just plain waste of time.