Just a quick update on a little project I’ve been working on over the past few months. Idiorm is “a lightweight nearly-zero-configuration object-relational mapper and fluent query builder for PHP5,” and is released under a BSD license.

Idiorm on GitHub.

The starting point for Idiorm was the topic of my talk at BarCampBrighton last year: “Minimalism in Web Development”, the idea that for many purposes, simpler solutions are often preferable to complex ones.

Idiorm lets you start using an ORM in your application with almost no effort. No XML files, model classes, database introspection or code generation is required: You just need to tell the ORM how to connect to your database, and away you go.

The fluent interface allows you to build most basic queries without writing any SQL, and gets out of the way when you need to do something more complex (both raw WHERE clauses and complete raw queries are supported). Once you have one or more instances of the ORM class (representing the rows in your database tables) you can access the data in them directly as properties of the objects (using PHP’s magic __get and __set methods internally), modify and save them, as well as delete them. For full documentation and lots of code samples, see the README file.

Obviously, such a simple project (the whole ORM class is only about 600 lines of code) would probably never be used in a huge, complex PHP application. The main drawback to using a generic ORM class instead of domain-specific model classes is that you can’t attach your own behaviour to the models. So the (extremely sensible) idea of placing most of your business logic in your models (Skinny Controller, Fat Model) isn’t possible with Idiorm as-is.

I have three answers to this problem. The first is that many applications simply don’t need any business logic more complex than basic CRUD operations, for which Idiorm is perfect. Secondly, one clear use case for Idiorm is to clean up legacy applications which are littered with raw SQL statements, usually passed directly into some custom-written “database abstraction” class or set of functions. Here, the application is already a mess, and in the absence of a complete rewrite, integrating Idiorm can only make things better. Finally, there’s no reason why you couldn’t build a full model layer as a lightweight wrapper on top of Idiorm. This would probably take the form of a factory object which returns instances of the correct model class, using Idiorm to populate them with data. I have a rough-and-ready implementation of this idea on my laptop which I may release at some point, but it’s easy enough to build yourself. If you’re using PHP 5.3 (and so have access to late static binding), you could even code up a pretty nice implementation of the active record pattern around Idiorm.

So to summarise, Idiorm isn’t really intended to replace something like Doctrine or Propel (or ActiveRecord, or Django’s ORM, or SQLAlchemy, etc). It’s designed to be a quick and easy solution to database abstraction in small-to-medium sized applications. And let’s face it – most of us are building small-to-medium sized applications. We’re building bicycles, not space shuttles. If Doctrine is a rocket engine, Idiorm is a bottom bracket. But if all you want to do is get to the corner shop, a bicycle is a much quicker way to travel.

Finally, if you think you’d find Idiorm useful, please let me know. Fork the project, make suggestions using GitHub’s Issues system or just leave a comment on this post.

Over the last few months, I’ve been kicking around a couple of little spare-time projects, and I’ve finally got round to writing a blog post about them. Both are fairly simple, but each represents a stepping stone in my efforts to bootstrap my brain into understanding the architecture and design of web applications.

First, http://hereit.is, a service for creating short urls for geographical locations. The idea is that you use the map on the homepage to find a location, and then create a short url to represent that location (such as http://hereit.is/brighton). You can then share this url by email, on the phone, on Twitter, etc. When the recipient(s) of the link visits the url, they are shown a simple landing page containing the map, with a link to Google Maps from where they can plan routes, see satellite imagery, and so on.

Despite its simplicity, hereit.is is built using modern web application principles. It has an MVC architecture and its design is quite closely based on that of Django. I decided to implement it in PHP (which I spend all day using at work), partly to prove to myself that it is at least possible to construct well-architected applications with this badly-assembled mess of a language. I now know that if I had used Django itself, the whole project would probably have taken me about half an hour – but the project itself wasn’t really the point. The point was to learn how frameworks are put together, and I have definitely succeeded at that.

I also wanted to get my head around REST, so hereit.is has simple API which you can use to create locations, and retrieve GeoJSON and KML representations of places. See the API documentation for more information.

For the front-end design, I took advantage nifty CSS3 tricks, such as border-radius and box-shadow. The main page of the site uses no images at all in its design, the idea of which appeals to the minimalist in me (of course, the map itself uses images). Even the logo is a Unicode character, inserted into the heading text with the :before pseudo-element.

I was invited to give a talk about hereit.is at £5 App, the brilliant monthly-ish meeting organised by Ian Ozsvald and John Montgomery. I gave a fairly high-level overview of how hereit.is works, and the talk should be fairly accessible (I hope) to the less technical types. You can see the talk on Vimeo here: http://vimeo.com/5664789

£5 App #18 – Jamie on HereIt.Is from Ian Ozsvald on Vimeo.

The second project is I Will Pay Your Parking Ticket. This is the brainchild of my friend Seb Lee-Delisle, who explains the idea much better himself.

He asked me to help out with the server-side implementation, which we decided to do with Django. It’s fairly straightforward for the most part, with one or two interesting details, such as the method we use to select which tweets to show on the homepage (simple randomness turned out to be quite inadequate), and the Twitter search API integration. Fortunately, you can see how it all works for yourself, because we decided to make the whole project open source. You can follow or fork it at Github.

This experience has completely sold me on the benefits of Django. At one stage, we more-or-less completely tore the application apart and rebuilt it from scratch in a few hours. There’s simply no way that would be possible with almost anything else. I’ve loved Python for years, so the ability to work on Web projects with it is fantastic.

Because of Seb’s rock-star status in the Flash world, and his thousand-plus followers on Twitter, I Will Pay Your Parking Ticket has been pretty popular. We already have nearly six thousand votes in the database. Deciding whether or not random strangers deserve your sympathy is a strangely addictive experience, and a good way to waste your lunch hour.

Again, Seb gave a talk about the idea at £5 App, which you can see below:

£5 App #19 Seb and Jamie with I Will Pay Your Parking Ticket from IanProCastsCoUk on Vimeo.

So, that’s a quick update on what I’ve been doing over the past few weeks. I’m trying to keep myself busy, with regular attendance at FlashBrighton and other events, as well as getting involved with the brand-new Brighton Hackerspace, BuildBrighton. I also managed to grab a ticket for BarCampBrighton 4 at the beginning of September. Hmm, I should probably decide what I’m going to talk about…

I spent the weekend at BarCampLondon6 at the offices of the Guardian near King’s Cross Station. I think my brain is too full of interesting things I’ve picked up over the last couple of days (not to mention too deprived of sleep) to actually process any of it into a coherent blog post, but you’ll get an idea of my thoughts by looking at my posts on Twitter tagged #barcamplondon6, and my Flickr set from the event. Thanks to the organisers for their hard work, and to all the people who took part.

My talk was about Processing. The photos below are by Rain Rabbit.

Me:

The audience (yes, I probably should have picked a bigger room):

You can view the slides on Slideshare:

Finally, here’s one of me playing with Auduino an Arduino-based synthesiser created by Peter Knight from tinker.it:

(click for the “live” version)

Feel free to leave a comment with your frame rate..

It is based on these instructions for vim, combined with this method to allow piping text into JSLint from the standard input.

1. Install SpiderMonkey
See the build instructions page for installing on many different architectures, or these instructions for quick installations on Ubuntu and CentOS 5.

2. Download JSLint SpiderMonkey Hack Edition
Get this version of JSLint which has been modified to allow piping code from the standard input. Save it somewhere in your home directory, say /home/username/bin/js/jslinthack.js. You’ll also need to make it executable by typing chmod +x /home/username/bin/js/jslinthack.js

3. Enable the External Tools plugin in gedit
Open gedit and click the Edit menu, then choose Preferences. Click the Plugins tab and tick to enable the Extenal Tools plugin.

4. Set up the JSLint External Tool
In gedit, open the Tools menu and click External Tools. Click the New button and give your new tool the name JSLint. Give it a descriptive name like “Check JavaScript source code”. Give it an Accelerator if you wish (mine is Shift+Ctrl+j). Set the Command to the location at which you saved the hacked JSLint file, eg. /home/username/bin/js/jslinthack.js. Set Input to Current Document and set Output to Insert in Output Panel (you’ll need to have the Bottom Panel enabled in gedit’s View menu).

5. Profit!
Open up a JavaScript source file, and either press your Accelarator keyboard shortcut, or go to Tools > JSLint. The results of the syntax check will be output in the bottom panel.

A few months ago, I spent some time writing a MIDI sequencer for the Arduino. I finished the sequencer, wrote a couple of songs with it, and then got sucked into MSc thesis mode and had to abandon it.

Well, I’ve finally got round to publishing it as an open source project on Google Code, so hopefully others will be able to have some fun with it. I’ve also written some documentation which will hopefully make it a little easier to get started creating music with it. I’ve named it ‘Cahors,’ which is a word I found in The Deeper Meaning of Liff. See the FAQ page on the Google Code side for a full explanation.

http://code.google.com/p/cahors/

You can hear the first full piece I wrote with Cahors on last.fm here, or you can download the MP3 from the Google Code project page. I’ve not had a chance to go back and write and more music for it recently, but hopefully I’ll get back into that soon.

In passing, he mentioned that his smoke effects were created using photographs of nebulae. He didn’t give any details about exactly how this works, but I thought it was such a good idea that I decided to have a go for myself.

The concept I came up with is simple: use a particle system to generate smoke-like behaviour, but instead of drawing each particle as a simple “blob,” draw an image of a nebula. The older the particle, the larger and more transparent the image. Fairly simple, but it creates remarkably realistic effects.

The particle system I used is based on the Traer physics library (in fact, I used some of their sample code to create the smoke behaviour) but you could use any system you like.

The images I used are show below. I took pictures of nebulae I found via Google and cropped out the most interesting parts, then applied a circular gradient mask in Photoshop and saved the resulting image as a transparent PNG. The original PNG images are included in the ZIP file which is linked at the bottom of this post.

Here are a couple of videos showing the results from this process:

UPDATE: The videos have been moved to Vimeo, please see: Smoke 1, Smoke 2, Smoke 3.

The Processing source code for my simple example (along with the images used to create it) can be found in this ZIP file: smoke.zip. If you run this code, you’ll first see the particles drawn as red dots. If you press the ‘i’ key, the images will be drawn. Pressing ‘p’ hides the red dots. Finally, the ‘m’ key toggles mouse following mode. Don’t forget, you’ll need the Traer physics library for this to work. I used the OpenGL drawing mode because it considerably speeds up image drawing, but it will work using the default Processing renderer.

This is just a basic sketch of how the idea works, and as I said, I have no idea if this is exactly how Robert Hodgin does it. Either way, I think it looks pretty good.

UPDATE: Videos have been moved to Vimeo.

I just noticed that I got linked to from Create Digital Motion, a blog about digital video production and computer animation. Cheers guys! However, the post says that there is “more at [my] personal site” and.. well, there isn’t. Or wasn’t, until now.

The post is about Radiohead’s “House of Cards” video which has been getting a lot of coverage on t’interwebs this week. I’ll spare the technical details as you’re almost certainly familiar with them by now (if not, have a look at this post). My two attempts (so far) are below, along with a little info about how they were made. You can view both the videos in higher quality by clicking through to YouTube Vimeo.

House of Cards, Experiment One from Jamie M on Vimeo.

The first set of experiments is based on a really simple particle system. The x, y and z co-ordinates of each point in the data cloud are turned into a particle, which is then “bounced” off a hard surface using very basic physics. The position of each particle of each frame in the video is calculated the correct number of times to produce the animation effect. By bouncing the particles at different angles relative to the “camera,” appearance of the bouncing particle cloud can be changed, creating some unusual visuals. The next section of the video is created by duplicating each point three times, to create three versions of Thom’s head. Finally, every particle is given a random velocity, creating an “explosion” effect which again is modelled as a large number of bouncing physical objects.

House of Cards, Experiment Two from Jamie M on Vimeo.

The second video is simpler: no physical simulation, just a set of lines. Every point is connected to another point with a line. The number of points slowly increases over the video, so Thom’s face slowly appears from randomness.

I’ve put some higher-quality stills from the videos on my Flickr account.

Note: I’m fairly sure you need to enable UI scripting for this to work.

1. tell application "System Events" to tell process "Dock"
set dock_dimensions to size in list 1
set dock_width to item 1 of dock_dimensions
set dock_height to item 2 of dock_dimensions
end tell

I’ve recently started using Twitter, but its “What are you doing?” functionality does have some overlap with the Facebook “Status“. It’d be nice to join these two things together, so that an update in one place would automatically update the other.

The current solutions to this (both the official Twitter Facebook app, and the unofficial Twittersync app) allow you to import your Twitter updates into Facebook. This is great for some people, but I’d rather not force all my none-geeky Facebook friends to put up with my geeky Twittering.

A better solution for me would be syncing from Facebook to Twitter. Facebook publishes an RSS feed of your status updates, and Twitterfeed can monitor feeds and post updates to Twitter. Perfect.. except it seems to be a bit flaky (I was getting double posts to Twitter of all my Facebook updates). It’s also lacking some customisation options which I’d like.

So.. if all else fails, do it yourself. Below is PyTwitFace, a Python script which grabs your RSS feed from Facebook, checks whether your most recent update has been posted to Twitter, and if not, posts it.

You will need:

• The python-twitter library.
• The Universal Feed Parser library
• The URL of your Facebook status RSS feed. Instructions to find it here.

This script doesn’t do any caching. It checks your recent Twitter updates to see if your Facebook status has already been imported. Twitter only publishes your twenty most recent Twitter updates via its API. So, if you update your Facebook status, then post 20 updates to Twitter, your status will be copied over again (duplicated). This isn’t a problem for me, but it may be for you.

The script does a bit of pre-processing of your Facebook status before posting it to Twitter. It chops off the first word (which is your name), and then checks whether the the next word is in a list of verbs (mine includes “is” and “has”, but you can add your own). It then appends “(from Facebook)” to the message. This means that a Facebook status of:

Jamie is trying out PyTwitFace.

will appear on Twitter as..

Trying out PyTwitFace (from Facebook)

Here’s the code. Don’t forget to have a look at it, and put in your Twitter username and password and your Facebook feed URL.

1. import twitter, feedparser, socket
2.  
3. #
4. # SETTINGS
5. #
6.  
7. twitteruser = 'username'
8. twitterpassword = 'password'
9. facebook_feed_address = "Your full Facebook status feed URL"
10.  
11. # Will be appended to facebook status
12. to_append = "(from Facebook)"
13.  
14. # These words will be removed from the
15. # beginning of your status if present
16. prefixes = ['is', 'has']
17.  
18.  
19.  
20. # Make sure the script doesn't hang if it can't get through to
21. # Twitter or Facebook (ie network is down).
22. timeout = 60 # seconds
23. socket.setdefaulttimeout(timeout)
24.  
25. #
26. # FACEBOOK STUFF
27. #
28.  
29. # Get most recent facebook status.
30. feed = feedparser.parse(facebook_feed_address)
31. most_recent_facebook = feed.entries[0].title
32.  
33. # Convert facebook status string into a list of words
34. most_recent_facebook_words = most_recent_facebook.split()
35.  
36. # Get rid of name from start of string.
37. del most_recent_facebook_words[0]
38.  
39. # If next word is in verb list, remove it.
40. if most_recent_facebook_words[0] in prefixes:
41. del most_recent_facebook_words[0]
42.  
43. # Capitalise first word.
44. most_recent_facebook_words[0] = most_recent_facebook_words[0].title()
45.  
46. # Append selected string.
47. most_recent_facebook_words.append(to_append)
48.  
49. # Convert back into a string
50. most_recent_facebook = " ".join(most_recent_facebook_words)
51.  
52. #
53. # TWITTER STUFF
54. #
55.  
56. # Set up API
57. twitterapi = twitter.Api(username=twitteruser, password=twitterpassword)
58.  
59. # Get list of statuses
60. twitter_statuses = twitterapi.GetUserTimeline(twitteruser)
61. twitter_statuses_text = [s.text for s in twitter_statuses]
62.  
63. # Check if your current Facebook status
64. # has already been posted to Twitter
65. if not most_recent_facebook in twitter_statuses_text:
66. # If not, post it!
67. twitterapi.PostUpdate(most_recent_facebook)
68.  
69.  

You can either run this manually when you update your Facebook status (which may slightly defeat the object), or put it on a server and set up a cron job, or (like me) run it automatically every so often on your own computer. I’m doing this using launchd in Mac OS X. See my Physical Gmail Notifier post for instructions of how to do this.

A final note: while I was writing this post, I came across Twitterbook, which does a similar thing with PHP. It does seem to require manually visiting the script’s URL to work though, which isn’t ideal. Try it out if you’re more of a PHP person.