Get Married
I’ve been engaged for well over a year, so it’s really time we started planning the wedding.

Run a half-marathon (and raise some money for charity)
Plymouth hosts a half-marathon run around the city in May each year, and this year I hope to be running rather than watching it. The last time I ran this distance was before I went to University, so I have a few months of training; 137 days according to the website, which doesn’t sound very long. I took the first tentative steps this week with a 3 mile jog, and will be keeping a training log on Twitter.

Unclutter
After Christmas, I made a start at ‘uncluttering‘ by donating clothes and clearing out things that ‘might come in useful’. Reading unclutterer.com, as well as books like the 4-hour work week, is inspirational for aiming for less (in a good way!). I’ll also probably check out Leo Babauta’s The Power of Less soon, although I have a wealth of books to get through at the moment.

Learn Ruby/Ruby on Rails (well!)
I’ve played with Rails and am currently developing a personal project to learn the more intricate parts of this powerful framework. Coming from PHP, Ruby seems incredibly clean and well-structured and my experience so far is that Rails is a nice framework to use.

At work, I’ve built a custom framework based on my experience with symfony to power the application I’m working on. I’ve recently found out, though, that a new project I’ll be working on is likely to be in Rails, so hopefully this will provide some motivation and time to get to know ROR properly.

I’m also using Ruby for some GTK apps (using the ruby-gtk bindings), as I’ve now moved exclusively to running Ubuntu on my machines. I have few open-source project ideas I’d like to get off the ground, and being able to use the same language for web and desktop apps makes sense.

Microblog More
Microblogging is a lot easier than writing long posts, and more suited to me, hence signing up to Twitter. So rather than promise to blog more, I’ll make sure I tweet more, and use this site as a repository of code, discoveries and pondering.

Release some software…
I’ve been working on a personal web project in Rails (see above) that I hope to release at least at a beta state within the next few months. I’ll hopefully be posting more about the development in the near future.

…and contribute to open source
As well as my main project, I’ve got a few small-scale open source apps I’d like to build, both for functional use and to hone Ruby-GTK It’s time I gave something back to the open-source community, especially now as I’m now exclusively using open-source desktop software.

This list is by no means exhaustive (and is a little tech-heavy), but hopefully will act as a guide for the next year. There will doubtless be lots of other goals cropping up, and things that I’ve forgotten about for now. My final goal, then, is to make sure I keep this list up-to-date.

rsync --bwlimit=500 ...

It turns out that rsync was overloading my router with data, causing it to reset the connection. Setting a bandwidth limit (in kBPS) to one nearer that of the router prevents overloading, and allows the scripts to complete.

SELECT to_timestamp('2008-08-01', 'YYYY-MM-DD') AS date;

A frustrating problem I came across today when I tried binding an NSPopUpButton’s selection key to an NSArrayController’s selection was that the NSPopUpButton would always display a ‘ghost’ object -one of the opaque classes internal to Cocoa/Core-Data Bindings(<_NSControllerObjectProxy… or similar).

It turns out that NSPopUpButton does not record the user’s selection, so even if I had been able to get rid of the ghost object, I wouldn’t have been able to access the selected object.

The solution is to manually maintain a currently selected object in the window controller - File’s Owner in Interface Builder; in this case, selectedPackage:

In MyWindowController.m:

- (void)setSelectedPackage:(NSManagedObject *)package
{
// ... checks ...
selectedPackage = package;
}
 
- (NSManagedObject *)selectedPackage
{
return selectedPackage;
}

In Interface Builder, the NSPopUpButton should be bound to the NSArrayController (Packages) and the File’s Owner as:

Content: Packages.arrangedObjects
Content Values: Packages.arrangedObjects;modelPath=packageName
Selection: File’s Owner.selectedPackage

A default selection can then be provided by calling the setSelectedPackage: method.

I’ve not had any time to try out Jaxer yet, but the idea of a single platform for both client and server-side processing sounds good.

On trying to get started, though, one problem I encountered was that the installation instructions on Aptana’s site didn’t quite get Jaxer running on my default Ubuntu 8.04 install. The reason seems to be the built-in Apache trying to load an external library from

/usr/lib

which doesn’t exist.

The library in question is libexpat.so.0; however, there is a libexpat.so.1.5.2 installed! You can check this by running:

$ ls -l /usr/bin | grep libexpat

Creating a link to this file in /usr/lib with:

$ ln -s libexpat.so.1.5.2 /usr/bin/libexpat.so.0

seems to have got Jaxer running and the server status looks good. If you’re having trouble getting a Jaxer server running on the latest Ubuntu, this might be worth giving a go.

To aid this process, each page controller PHP class has a corresponding Javascript class. In order to maintain state through the application, each class as a Singleton. With the help of Prototype, singleton classes are quick and easy to implement in Javascript:

First, declare the class itself using Prototype’s Class.create() method:

PageController = Class.create({
	/**
	 * @type {integer}
	 */
	userId: null,
 
	// ... more properties ...
 
	/**
	 * Constructor
	 */
	initialize: function()
	{
	// ...
	},
 
	/**
	 * A method to do something...
	 */
	doSomething: function()
	{
		console.log('doSomething()');
	},
 
	// ... more methods ...
});

Once the class is created, we can declare a static instance of the class and a static method, getInstance(), that will be used to return the single instance of the class:

/**
 * @type {PageController} Static instance of the page controller
 */
PageController.instance = null;
 
/**
 * Return the static (singleton) instance of
 * the page controller object
 */
PageController.getInstance = function()
{
	if(!PageController.instance)
		PageController.instance = new PageController()
 
	return PageController.instance;
}

With the class now declared, the singleton instance can be accessed in your application using the static getInstance() method:

PageController.getInstance().doSomething()

The API uses Google’s GData format, which is something I’m yet to look into. It would seem to be a‚ good time to put into practice some Python‚ - or maybe dust off the Objective-C - and‚ Cocoa.

The Problem
When using calendar software, it is painful to have to click between each field, setting hours and minutes, locations etc. then confirming with an OK. I have been known (more often than not) to forego any form of calendar, instead relying on scrawl left on scraps of paper around the office. Whilst less organised than a calendar, this said scrawl is a lot easier to jot down. Needless to say, though, it is also a lot easier to lose.

A Solution
In Google Calendar, the designers have captured my need to quickly jot down when, where and who. No longer do I need to tab between fields, carefully tapping out 24-hour clocks (or 12-hours, depending the software’s mood). Instead, events can be entered as simply as:

meet joe at company friday 11am

Google Calendar will then automatically pick out the important information and add the appropriate event. No fussing around with mini-calendars or remembering to use mm/dd instead of dd/mm - the app just works. This is, for me at least, near-perfection user design - and I hope more software begins to take note (Apple’s new iCal 3.0 does not).

Google Calendar’s ‘Quick Add’ is an example of removing layers of abstraction (or barriers) between the user and the system, and quite correctly why should the user conform to the system? It should surely be the other way round. Mobile phone OS designers should note, why should it take 4 menu items to get to a message inbox? Perhaps Google’s new Android will help to iron that one out…

For example, a Client managed object can get a count of owned domains that are expiring soon. This is a transient propety, accessed through a key of expiringDomains. It simply returns an NSSet which is built from a fetchRequest.

Previously, I was running this fetchRequest each time the key was accessed. This was admittedly inefficient, but seemed functional - at least until you saved the document.

Something crazy happens when a Core Data document is saved - all the objects in a context are released (faulted). There is a good reason for this, as it frees up any memory that was being used to temporarily store the managed objects. However, it caused very strange results to appear in my transient properties; namely, they would all vanish.

Even forcing the fetch request to refresh didn’t pick up any objects from the context (I’m not sure why as I would have expected the faulted objects to be ‘refired’). So I took the plunge and refactored the Client object to cache its expiringDomains value. After some extensive testing and finger-crossing, I’m fairly sure this is the correct way to handle transient relationship properties:

CustomManagedObject.h

@interface CustomManagedObject : NSManagedObject {
ame NSSet *transientRelationship;
}
 
- (NSSet *)transientRelationship;

CustomManagedObject.m

#import "CustomManagedObject.h"
 
@implementation CustomManagedObject
 
- (void)awakeFromFetch
{
ame [super awakeFromFetch];
 
ame // set managed object to observe changes to the context, this is necessary
ame // to monitor changes to the context that occur elsewhere in the app
ame [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(refresh:) name:NSManagedObjectContextObjectsDidChangeNotification object:[self managedObjectContext]];
 
ame // clear the cache after managed object is fetched into the context
ame if( transientRelationship != nil )
ame [transientRelationship release], transientRelationship = nil;}
 
- (void)refresh:(NSNotification *)notification
{
ame // ... perform check to see if update is neccessary, assume it is...
 
ame if( refreshNeeded ) {
ame if( expiringDomains != nil )
ame gDomains release], expiringDomains = nil;
ame }
}
 
- (NSSet *)transientRelationship
{
ame [self willAccessValueForKey:@"transientRelationship"]
ame
ame if( transientRelationship == nil ) {SFetchRequest *aFetchRequest = [[[NSFetchRequest alloc] init] autorelease];
 
ame [aFetchRequest setEntity:[NSEntityDescription entityForName:@"DestinationEntity" inManagedObjectContext:[self managedObjectContext]]];
 
ame // optionally, set a predicate, e.g. owner == self
ame [aFetchRequest setPredicate:[NSPredicate predicateWithFormat:@"predicateString"]];
 
ame NSArray *results = [[self managedObjectContext] executeFetchRequest:aFetchRequest error:nil];
 
ame transientRelationship = [[NSSet setWithArray:results] retain];
ame }
ame
ame [self didAccessValueForKey:@"transientRelationship"]
 
ame return transientRelationship;
}