When I realised this I was 31 years and about 7.5 months, and since then I thought the day for me was yesterday. (I even noted so on twitter. And Facebook. The shame.) However today I was challenged on it. Since I could not find the program I wrote previously I whipped up a new one. Here it is:

#!/usr/bin/perl
use strict;
use warnings;
use DateTime;
my $date = DateTime->new( time_zone => 'floating', @ARGV )
	or die "Could not get date from input!";
printf "If your birth date is: %s\n", $date;
for (qw/ 1e6 1e9 /) {
	my $date2 = $date->clone->add( seconds => $_ );
	printf " .. your birth date plus $_ seconds is: %s\n", $date2;
}
printf " .. and you are now %d seconds old\n", (DateTime->now->epoch - $date->epoch);

I then texted mom to find out exactly when on the day I was born and after a quick response could call the script with the following arguments:

./1e9.pl year 1978 month 4 day 24 hour 12 minute 35

The output produced is:

If your birth date is: 1978-04-24T12:35:00
 .. your birth date plus 1e6 seconds is: 1978-05-06T02:21:40
 .. your birth date plus 1e9 seconds is: 2009-12-31T14:21:40
 .. and you are now 1000012821 seconds old

So, it turned out that I either misremembered or miscalculated before: today is actually the day when I turned 1,000,000,000 seconds old. Happy 1e9 seconds day to me!

Here are the more significant changes from the 2.1 series:

• New, fresh API—particularly for errors

  Extracted the SBJsonWriter and SBJsonParser classes from the SBJSON class. These present a fresh, simple API. If a method returns nil, you can now simply call a method to get an array of NSError objects containing the error trace.

  The SBJSON class is now a facade, implementing its old interface by forwarding messages to instances of the new classes. Additionally, the facade also implements the new simplified interface of the SBJsonWriter and SBJsonParser classes.

  The category methods on Foundation objects have also been re-implemented more efficiently in terms of the new objects. In case of error in these methods now print the full trace to the log, rather than just the top-level error.

• Support for JSON representation of custom objects

  If you implement the -proxyForJson method in a custom class (either directly or as category) this now enables JSON.framework to create a JSON representation for objects of that type. See the ProxyTest.m file for more information on how this works.

• Deprecated fragment-based methods

  The fragment-based methods are an extension to the JSON spec that does not belong in a strict JSON parser/generator. They were originally implemented to ease testing, but the tests should rather be rewritten not to need them. For the time being they are still included, but will be removed in the 2.3.x line.

• Updated the iPhone SDK

  The iPhone SDK has had some updates to address problems some people were seeing. It has been updated to be based on iPhoneOS v2.2.1.

• Fix crash on recursive structures

  Implemented the maxDepth setting for writing JSON. This defaults to 512 and means the framework won’t crash if its is fed a recursive (or extremely deeply nested) structure.

• Documentation updates

  Simplified the installation instructions, particularly for the iPhone.

  In the API documentation classes now inherit documentation from their superclasses and the protocols they implement.

• Miscellaneous

  Fixed some warnings reported by the Clang static analyser.

  Added a Changes file and updated the Credits.

• I don’t need separate hosting for the generated API documentation.
• The API documentation benefits from whatever versioning scheme you adopt in Subversion.
• By hooking the script into your release process you can make sure that the documentation is always up to date.

However, there’s a couple of things that may snag you too:

• It requires that your Subversion repository is available over HTTP.
• You have to set the mime-type of the various file types correctly. Otherwise you just get the raw content of each file.
• You have to deal with adding and removing files when the documentation changes.
• Doxygen puts a timestamp in every file so every time you regenerate the documentation all the files will appear to have changed. That’s a lot of unnecessary updates if you’re barely tweaking the version number for a patch release.

If you’re using Google Code your repository is already available over HTTP. The below script snippet deals with the remaining issues. It assumes that you have already run Doxygen and generated documentation in /tmp/doxygen, and that you are running it from your Subversion checkout, and that the directory that contains the API documentation is called apidocs.

rm -f apidocs/*
cp -p /tmp/doxygen/html/* apidocs
cd apidocs

# Revert files that only has one line removed
# and one added. They differ only in the timestamp.
svn diff *.html \
	| diffstat \
	| awk '$3 == 2 { print $1 }' \
	| xargs svn revert

# Add/remove files from subversion.
svn st | awk '
    $1 == "?" { print "svn add", $2 }
    $1 == "!" { print "svn delete",  $2 }
' | sh -

# Set mime-types so files display properly
# rather than just display their raw content.
svn propset svn:mime-type text/html *.html
svn propset svn:mime-type text/css *.css
svn propset svn:mime-type image/png *.png
svn propset svn:mime-type image/gif *.gif

Notice that it doesn’t actually submit the changes, so you can verify that the generated documentation looks like you want it to before you check it in.

The GMail web interface showed that “enough” mail had made it over. (All apart from that message, I believe.) So the solution was simply to kill that account from Mail.app, and recreate it immediately. Problem solved instantly.

I enjoy mucking about with games so revisiting Phage, an abstract strategy game I wrote last year, seems an apt exercise. It’s only at version 0.2.1 and the low version number reflects the clunkiness of the UI. I’m going to give this game a complete overhaul for version 1.0, and this time I’m not taking UI short-cuts. Here’s a screen shot of the work in progress:

I’m using Core Animation to do the visual elements of the game. It took some time before I managed to wrap my head around how to make a re-sizeable grid of CALayer instances, but once I finally did the rest has been pretty smooth sailing. It’s really satisfying resizing the window and see the graphics smoothly scale up or down!

Looking at the source of the GeekGameBoard example project from Apple has been a huge help. It’s a bit hard to follow sometimes as it actually implements five quite diverse games but it is full of gold nuggets. I don’t like its tight coupling between the UI and the game logic, however, and I’m currently working on cleanly marrying my shiny CALayer based View to my Model classes.

Psst: I’m planning to also release this on the iPhone. I’ll announce it here when I do, so if you’re interested: keep checking back!

Enter CAConstraintLayoutManager. I initially tried to constrain each cell to neighbouring cells, and to the super layer for the “outer” cells. Not only was this messy; I couldn’t make it work at all—not even with a 1 by 5 “grid”. I suspect that the layout manager is getting a bit confused because I don’t specify the size of any dimension of any cell.

Then I discovered the scale-argument form of the NSConstraint. With this I can specify the size of a cell and its position in the grid only in terms of the super layer. This is much much simpler. Have a look at the example code below. Paste it into a custom view, and it should display a gray grid on a pleasant blue background:

- (void)awakeFromNib {
    self.wantsLayer = YES;
    CALayer *grid = self.layer;

    grid.backgroundColor = CGColorCreateGenericRGB(0.1, 0.1, 0.4, .8);
    grid.layoutManager = [CAConstraintLayoutManager layoutManager];

    int rows = 8;
    int columns = 8;

    for (int r = 0; r < rows; r++) {
        for (int c = 0; c < columns; c++) {
            CALayer *cell = [CALayer layer];
            cell.borderColor = CGColorCreateGenericGray(0.8, 0.8);
            cell.borderWidth = 1;
            cell.cornerRadius = 4;
            cell.name = [NSString stringWithFormat:@"%u@%u", c, r];

            [cell addConstraint:
             [CAConstraint constraintWithAttribute: kCAConstraintWidth
                                        relativeTo: @"superlayer"
                                         attribute: kCAConstraintWidth
                                             scale: 1.0 / columns
                                            offset: 0]];

            [cell addConstraint:
             [CAConstraint constraintWithAttribute: kCAConstraintHeight
                                        relativeTo: @"superlayer"
                                         attribute: kCAConstraintHeight
                                             scale: 1.0 / rows
                                            offset: 0]];

            [cell addConstraint:
             [CAConstraint constraintWithAttribute: kCAConstraintMinX
                                        relativeTo: @"superlayer"
                                         attribute: kCAConstraintMaxX
                                             scale: c / (float)columns
                                            offset: 0]];

            [cell addConstraint:
             [CAConstraint constraintWithAttribute: kCAConstraintMinY
                                        relativeTo: @"superlayer"
                                         attribute: kCAConstraintMaxY
                                             scale: r / (float)rows
                                            offset: 0]];

            [grid addSublayer:cell];
        }
    }
}

Things aren’t so simple if you want to have some spacing between the cells. I suspect you have to pack a cell within an intermediate CALayer, or add some custom drawing to each cell to draw the border a bit inset from the edge of the cell.

Update: It turns out that using this method to create a grid with spacing between the cells is not much harder after all. The below replacements for the constraints above give you a 2-pixel spacing between the tiles. I’ve highlighted the differences in bold text.

[cell addConstraint:
 [CAConstraint constraintWithAttribute: kCAConstraintWidth
                            relativeTo: @"superlayer"
                             attribute: kCAConstraintWidth
                                 scale: 1.0 / columns
                                offset: -2]];

[cell addConstraint:
 [CAConstraint constraintWithAttribute: kCAConstraintHeight
                            relativeTo: @"superlayer"
                             attribute: kCAConstraintHeight
                                 scale: 1.0 / rows
                                offset: -2]];

[cell addConstraint:
 [CAConstraint constraintWithAttribute: kCAConstraintMidX
                            relativeTo: @"superlayer"
                             attribute: kCAConstraintMaxX
                                 scale: (c + 0.5) / (float)columns
                                offset: 0]];

[cell addConstraint:
 [CAConstraint constraintWithAttribute: kCAConstraintMidY
                            relativeTo: @"superlayer"
                             attribute: kCAConstraintMaxY
                                 scale: (r + 0.5) / (float)rows
                                offset: 0]];

iPhone-ready SDK
The disk image now contains a Custom SDK. This makes the framework a lot easier to use on the iPhone. See the INSTALL file in the dmg for details.

New sortKeys option
This makes the generator produce objects with the keys in sorted order. This is very handy when you need to compare JSON documents.

Leopard only
From version 2.1 onwards this framework is Leopard-only. Stick with version 2.0 if you need Tiger support. Some of the Objective-C 2.0 features are just too shiny to pass up for long. Some of the changes related to this:

• 64 bit support
  The JSON framework now supports 64 bit. Moved to use the 10.5 64-bit compatibility typedefs for basic types.

• Garbage collection support
  The framework is now built with garbage collection support by default.

• Syntesized properties
  Killed some redundant code by moving to use synthesised properties.

• Fast iteration loops
  Update the code to use Objective-C 2.0 fast iteration loops in a couple of places.

Removed deprecated methods
Removed the option-taking category methods, as promised in v2.0. Rewrote some tests to use the underlying object instead.

New error code
Introduced a new error code for clarity: EEOF – premature end of input.

Documentation target
Added a documentation target to integrate the documentation into Xcode automatically.