// Measure parent fork time
syscall::*fork*:entry { /* save start of fork */
	self->fork = vtimestamp;
}

Sadly, those tools aren’t available on a standard issue Linux machine. (You can do it with SystemTap, but it’s not on every server I end up looking at.) Today I was trying to track down some processes that were making very odd DNS lookups. I isolated the user ID making these calls via iptables logging:

iptables -I OUTPUT 1 -m string --string "BADZONE" -d 127.0.0.1 -p udp --destination-port 53 --algo bm -j LOG --log-uid --log-prefix "BADZONE: "

But this user’s PHP scripts were getting launched and dying again quickly. How to find out what was going on inside them? This hacky little trick actually worked really well. You can download it from my git utilities directory.

Basically, we check the process list as fast as we can for any owned by that user; If you find one, stick an strace on it. The script will ‘hang around’ until all the strace processes have finished. You end up with a directory full of trace files which you can then post-grep through to get what you need.

The short version is I was able to catch one of that user’s programs doing the odd behaviour within about 30 seconds of running this tool, which was great!

#!/usr/bin/perl

use warnings;
use strict;
use Getopt::Long;

my $opt = {};
GetOptions($opt, "uid=i", "number=i", "help", "man");

if($opt->{help} || $opt->{man} || !defined($opt->{uid})) {
    print "Usage: auto_stracer --number <processes to capture> --uid <numeric uid>\n";
    exit;
}
$opt->{number} ||= 5;

my $traced = 0;
my %seen = ();
my @pids = ();
my %ourpid = ();
$ourpid{$$}++;

$SIG{INT} = sub { kill 9, @pids; print "Interrupt: Killed all running strace processes and quitting.\n"; exit;};

while ($traced < $opt->{number}) {
    for my $line (split(/\n/, `ps -Ao 'uid,pid'`)) {
        $line =~ s/^\s+//g; # eat leading spaces
        my($uid, $pid) = split(/\s+/, $line);
        next if($ourpid{$pid}); # don't run on something we are tracking
        if($pid && $uid eq $opt->{uid} && !$seen{$pid}) {
            $seen{$pid}++;
            my $st_pid = do_strace($pid);
            $ourpid{$st_pid}++;
            push(@pids, $st_pid);
            $traced++;
            last if ($traced >= $opt->{number});
        }

    }
}

print "Traced $opt->{number}, waiting for all to finish\n";
my $kid = 0;
do {
      $kid = waitpid(-1, 0);
} while($kid>0);
print "All processes completed, exiting.\n";
exit;

sub do_strace {
    my($pid) = @_;
    my $ourpid = fork();
    return $ourpid if($ourpid != 0);
    my $cmd = "strace -p $pid -f -s 65535 -o trace.$pid.$$ -v";
    print "\tcmd: $cmd\n";
    system($cmd);
    exit;
}

So, very brute force compared to the elegance of systemtap or DTrace, but when you need it, it’s still handy.

This one’s going to get complicated, so here’s the tl;dr version. To get the shortest possible, web-safe identifiers:

• encode identifiers with base62 or a customized version of base64 that uses valid characters.
• Use a big enough hash space to get an acceptable level of collisions.

Ok. Here’s the long-winded version.

It’s a little like the “URL Shortener” use case, where you want to take a big fat link and describe it in a tiny link. In this case, I’m converting individual sentences into a tiny, linkable representation.

So, I need a very short identifier that obeys certain (conflicting) properties:

• As much as possible, the identifier should be the same regardless of the order that I create the sentences in
• It should be as short as possible, because I may need to refer to a lot of these in a single URI

In the URL shortener mode, they tend to solve this by just keeping a global “ID” counter and incrementing it every time someone creates a new link. I need to use something a lot more like a hash. (MD5 or SHA1 are typical choices here.)

So what are the constraints?

• How long can a URI be?
• What characters are we allowed to use?
• How much unique data is going to be represented?
• How tolerant can we be of collisions? (When 2 “objects” might map to the same shortened identifier?)

URI constraints

The first 2 are simple and global. There’s no real standard on URI length, but smart people have done the legwork for us so we’ll steal their conclusions, and say “keep URI’s shorter than 2,000 characters.”

As far as the characters that can be used, we can consult RFC 3986 in the “Unreserved Characters” section and find we’re allowed 0-9, a-z, A-Z, and “- _ . ~” (dash, underscore, dot, tilde.) I’m going to avoid using those because I’d like to keep them for separating my identifiers. So, if we just go with the “normal characters”, there’s 62 of them.

Collision Constraints

If you assume a hashing function generates numbers pretty randomly spread throughout the number space available to it (which I will for this) there’s actually some pretty good math we can use to figure out how likely a collision will be. If you’re interested in where this comes from, check out the Birthday Paradox, which is nicely written up at Wikipedia. Using the formulas there you can calculate the probability of having 2 keys that collide, as a function of how many things you’re trying to insert, and the size of the overall hash space.

Putting it all together

First, figure out how many items you want to be able to store. (for me, 20,000 is a high estimate).
Second, figure out how comfortable you are with having some keys collide. 50/50 odds? (0.5) 1/1000 chance? (0.001)
I’m actually pretty ok having a very small number of collisions — I’m going to use 0.99, a 99% chance that SOMETHING will collide. (That’s still going to be a small number, less than a 100% chance that anything at all will collide, let alone more than one.)

I sketched up a little script for this article (which you can grab from my git repo. It’s pretty self-documenting, so I’ll let it speak for itself.

The goal is, given our constraints, and the fact that we need to use only the characters 0 .. 9, a .. z, A .. Z, (a) how many of those characters do we need, and (b) given that it probably won’t be an exact fit, what will our collision probability end up being?

my ($items, $probability) = (0,0);
GetOptions("items=i" => \$items, "probability=f" => \$probability);

printf("Trying to store %d items with a %0.5f chance of collision\n", $items, $probability);

# solve the birthday paradox in terms of 'how big the range should be'
# http://en.wikipedia.org/wiki/Birthday_paradox#Calculating_the_probability => wolfram alpha, 'solve for d'
my $max = -1*(($items - 1)*$items)/(2 * log(1-$probability));

print "To do that, we'd need to be working in the range 1:$max\n";

# compare that back to the original formula from Wikipedia and make sure that worked
my $calculated_prob = get_probability($max, $items);

printf("probability %0.10f should match your requested probability of %0.10f, or something went wrong.\n", $calculated_prob, $probability);

# so it does, cool
# how many bits would it take to represent $max?

my $frac_bits = log($max)/log(2);
my $real_bits = int($frac_bits)+1;

printf("This can be represented by %0.2f bits (%d)\n", $frac_bits, $real_bits);

# ok, so how about encoding those into URI's? We can use 0-9, a-z and A-Z, which gives 62 "digits"
# aka base62. $max in base62 can be calculated like we did "how many base2 digits were needed"

my $base62_digits = int(log($max)/log(62))+1;

print "Using 0..9, a..z and A..Z we can represent each object with $base62_digits digits\n";

# ok, if we're using 5 digits, what's our actual "space" and what's the probability of a collision?

my $newmax = 62**$base62_digits - 1;

# which is actually how many bits?
my $newbits = int(log($newmax)/log(2));

printf("Given that we'll have to use %d digits, (%d bits), the real probability of a collision is %0.10f\n", $base62_digits, $newbits, get_probability($newmax, $items));

sub get_probability {
    my($max, $items) = @_;
    return 1 - (($max - 1)/$max)**(($items*($items-1))/2);
}

The most mysterious parts of this are probably the formulas. The one in the get_probability subroutine is transcribed right from the Wikipedia page, but the other one is the same formula, solved for a different value. In general, if you need to do this, WolframAlpha is a math nerd’s dream come true. I just asked it to “solve (the equation) for d” and got the new formula I needed.

The solution actually comes from “show your steps” — I can find an intermediate form that’s easier to represent in a non-math-centric programming language. (I’m sure you can do imaginary numbers in perl, but it was kind of outside the scope of my plans for this evening.)

Here’s the formula I ended up using:

Here’s a few sample runs of the script:

First, using my personal constraints for this project:

./hashspace_model -i 20000 -p 0.99
Trying to store 20000 items with a 0.99000 chance of collision
To do that, we'd need to be working in the range 1:43427276.7179157
probability 0.9900000006 should match your requested probability of 0.9900000000, or something went wrong.
This can be represented by 25.37 bits (26)
Using 0..9, a..z and A..Z we can represent each object with 5 digits
Given that we'll have to use 5 digits, (29 bits), the real probability of a collision is 0.1961141788

Cool! So I said I’m ok with a 99% chance of a collision, and the algorithm figured out that in order to do that, I’d need to be using 5 digits of base62. And if I’m using 5 digits of base62, I get 3 more bits than I strictly “need”, which means I end up with only about a 1/5 chance of EVER getting a collision.

Let’s say I wanted to be more strict, and go “one in a million”.

./hashspace_model -i 20000 -p 0.000001
Trying to store 20000 items with a 0.000001 chance of collision
To do that, we'd need to be working in the range 1:199989899999232
probability 0.0000009992 should match your requested probability of 0.0000010000, or something went wrong.
This can be represented by 47.51 bits (48)
Using 0..9, a..z and A..Z we can represent each object with 8 digits
Given that we'll have to use 8 digits, (47 bits), the real probability of a collision is 0.0000009103

In this case base62 comes pretty close to exactly the dimensions that we want, so we more or less get 1/1,000,000 on the nose with 8 digits.

If you grab the script to play with, you may need to tweak the printf’s and make sure they have enough resolution for the data you’re trying to examine.

Ok, so that tells us how bit our bitspace needs to be, but not how to get a hash, or how to do base62.

Hashing Function

I chose md5 because…. it seems to work fine. I’m sure there’s a better option, but this is working for now. However, md5 has a lot more bits available than I need. How to just steal a few of them?

First, you need to know how many bits you want. Thankfully, I know I want 29 bits (thanks, helper script!). I can extract 29 bits of information from it by making a “mask” of 29 1′s, which can be done easily like so:

my $mask = 2**29 - 1;

So, now I just need a raw integer slice of an md5, and do a “logical and” of that:

use Digest::MD5 qw(md5);
# unpack makes this back into an integer for us
# L == interpret the data as a 32 bit unsigned long.
# See 'perldoc -f pack' for a ton of other options
my $value = unpack("L", md5("the string we want"));
$value = $value & $mask;

Groovy. Now we know what number we want to represent, we need to actually represent that in this weird “base62″ format.

The algorithm for converting to base(anything) is actually pretty easy.
We’re used to thinking in base10, so I’ll show an example of running the algorithm to from and to base10, just so the flow is clear.

Simple enough to understand in base10, but the exact same technique works when going from base10 to any other base (2 would work to convert to binary, we’re using 62, and if you could find enough characters, you could go to something crazy like base300 using the same idea.)

Here’s the source for it:

# even though they are letters we are using them here in the role of "digits"
my @digits = (0 .. 9, 'a' .. 'z', 'A' .. 'Z');
my %digits = map { $digits[$_] => $_ } 0 .. $#digits;

sub to_base {
    my($base, $value) = @_;
    die "base $base out of range 1-62" unless ($base > 0 && $base <= 62);
    return $digits[0] if $value == 0;
    my $rep = "";

    while($value > 0) {
        # prepend the "digit" we get when dividing by the base
        $rep = $digits[$value % $base ] . $rep;
        # then "shift right" the working value
        $value = int( $value / $base );
    }
    return $rep;
}

sub from_base {
    my($base, $rep) = @_;
    die "base $base out of range 1-62" unless ($base > 0 && $base <= 62);
    my $value = 0;
    # this pattern grabs a character at a time, left to right
    for ( $rep =~ /./g ) {
        $value *= $base;
        $value += $digits{$_};
    }
    return $value;
}

So there you have it. Provably optimal URI-compatible identifiers with 3 easy steps:

1. Figure out what the constraints for your problem space are
2. Grab enough bits from md5
3. Convert to (and from) base62

You’re liable to see a mount that looks like this:

$ mount | grep noexec
/dev/simfs on /tmp type simfs (rw,noexec)
/dev/simfs on /var/tmp type simfs (rw,noexec)
devpts on /dev/pts type devpts (rw,nosuid,noexec)

However, sometimes that’s a problem, for example if you run the fantastic checkinstall tool to package software. You might see an error message like this:

/usr/bin/installwatch: /var/tmp/tmp.SuogJyYftZ/installscript.sh: /bin/sh: bad interpreter: Permission denied

The noexec permission has gotten us. How to work around it?
Here’s a quick, easy to roll back method:

# make a new temporary directory for this use
mkdir ~/tmptmp
# use mount --bind to overlay this on our 'real' /var/tmp for now
$ sudo mount --bind ~/tmptmp /var/tmp
# do your work
$ sudo checkinstall make install
# restore the natural order to the universe
$ sudo umount /var/tmp

You could also (potentially) remount /tmp without that option temporarily, but that isn’t always possible. (See ‘virtuozzo’ above.)

1. Use a Time Capsule
2. Run Snow Leopard Server, which allows you to set remote drives as Time Machine volumes
3. Mount the iSCSI share via an “initiator”, and use it like it was a normal hard drive.

I’m not sure I’d want to use the iSCSI option with a laptop, so I use a hybrid of the second and third options.

I’m running Snow Leopard Server on a Mac Mini with limited disk space. I’ve got a large server running OpenSolaris about which I blogged previously.

Here are the brief steps you need to take to get it working.

On the Snow Leopard Server, install the ISCSI initiator from GlobalSan.

On your OpenSolaris server, make sure you’ve installed the support packages needed.

pkg install SUNWiscsi SUNWiscsitgt

Now, from one of your available disk pools, create the virtual hard drives for your servers to mount, (making sure you make them about 1.5x larger than the disks you’re trying to back up, so you can get historical information from them.

zfs create -o shareiscsi=on -s -V 160GB mypool/laptop_tm
zfs create -o shareiscsi=on -s -V 140GB mypool/server_tm

To find out what the “target ID’s” are, run this:

iscsitadm list target

shows the target names to paste into the initiator.

You can follow the instruction at this blog on sun.com which has screenshots of the rest of the process.

At this point the drives are just like regular disks, from the perspective of your Mac (desktop or server) — and can be formatted and used for Time Machine. Very convenient and the data that you’re backing up will be in the safe, safe hands of ZFS in the event of a disk failure.

The problem: You have a puppet function you find useful. At this point custom functions are really easy to create and distribute via modules so there’s really no reason not to be using them. However, you want to use the result of a function in your templates.

A real-world example of this is sharing authentication information. (For example, crypted password hashes. Plain text, as always, would be evil no matter where it was living.)
You really have 3 choices:

• Coding it right into your puppet code and checking that into your version control system
• Not distributing that information with puppet
• Using puppet to distribute the information, but store it outside of your puppet modules somehow.

We chose the third way, and store this kind of information in YAML files outside the puppet modules tree.
Anyway. So we want to access this info inside a template.

Assume you have a function called ‘get_extdata’.
You normally call from your ‘.pp’ manifests with something like

$data = get_extdata('mymodule', 'path:to:data')

You can make a call like that from your template by doing this wonderful fragment of magic-wand-waving to get this function accessible:

In mytemplate.erb:

<% Puppet::Parser::Functions.autoloader.loadall %>
Now you can use the 'scope' variable to get at your function.
This is the equivalent of the call get_extdata('mymodule',  'path:to:data'):
<%= scope.function_get_extdata('mymodule',  'path:to:data') %>

This works like a charm, and means you don’t have to create a bunch of variables that you don’t really need before you load the template.

So if you were creating an .htpasswd style file with puppet, you could do

In your init.pp

$users = ['steve', 'paul', 'stu']

htpasswd.erb:

<% Puppet::Parser::Functions.autoloader.loadall %>
<% users.each do |user| -%>
<%= user %>:<%= scope.function_get_extdata('authmodule',  user) %>
<% end -%>

Since then, the world has changed. I’ve upgraded to Snow Leopard, and Quicksilver has essentially stopped working out for me. (I’ve been trying to keep it up to date, and sometimes it kind of works, but my confidence levels are really low.) On the other hand, I’m loving me some Google Quick Search Box (a new project from the original creator of Quicksilver). The only feature that I still wanted Quicksilver for was triggers. And until today, I was still running it for trigger support to implement my Inbox Zero trick.

And then triggers broke when I upgraded it. And I’m out.

So here’s how to get Inbox Zero magic in Mail.app using only tools native to Snow Leopard.

First, launch Automator and create a new Service workflow.

Select “Utilities” and then drag in “Run Applescript” to the window on the right.

Fill in your applescript, replacing only the center “comment” block — leave the other autogenerated lines there.

The core code again, (tweak to fit your accounts and archive mailbox names)

tell application "Mail"
	set theSelectedMessages to selection
	set myAccount to "zimbra"
	set myMailbox to "Archive"
	repeat with theMessage in theSelectedMessages
		move theMessage to mailbox myMailbox of account myAccount
	end repeat
end tell

It should look something like this:

And that’s it! Save it, and give it a name you’ll remember. (I chose “Archive Selected Mail.”)

Now it’s actually in Mail’s Menu (under ‘Services’) and we can use the built in OSX hotkey support to launch it.

Go to the System Preferences Menu, click “Keyboard Shortcuts”, and add one for the menu item you created. (It needs to be the same exact name you saved your service as.)

Badda bing. Feature complete, and I can (sadly) retire Quicksilver forever. This technique should be extensible to all kinds of other cases when you want to add new features to applications, for access either through the menus or with hot keys.

Here are some screenshots from my strace-based ‘magic profiler’ (which I still promise to talk more about later.)
It lets you attach to a process which is about to render your website, and then trace all the interactions it has with the underlying system while it renders it.

That includes network traffic, file server traffic, DNS resolver lookups — everything your app does to communicate to the outside world. The timing is always going to look slower than normal (at least a bit) as the tracing does impose some overhead, but it’s relatively pretty accurate.

Here’s what I saw right after telling WP Widget Cache to clear the caches.

And here is what I saw on the second hit:

I have widgets to load Flickr, (the entry with ‘flickr’ in it) delicious bookmarks, (the yahoo one) and Twitter. (The naked IP. Apparently they don’t like PTR records.) Those three external calls dominated my total time to generate the page. Now, it’s down to a very quick MySQL lookup and a chatty conversation with a fileserver.

One feature I especially appreciate is the ability to tune cache times per widget. If I want new Flickr photos to be available hourly, sure. If my tweets need to be there within 5 minutes, not a problem. And because the widgets are there every time anyone uses any part of the site (even the rarer ones) it plays really well with the other WP Cache Plugins.

The issue was that the sensor was fine, except when it was rapidly transitioning from one temperature to another. For example, if the ambient temperature was 74, and suddenly a can of soda fresh from the fridge was placed on it, you’d get several “transitional readings” (70, 68, 52, 48, …) until the temperature finally stabilized.

We talked about various ways of detecting this case, but the most straightforward one seemed to be Standard Deviation, which Wikipedia explains much more clearly than I could.

I googled around for sample code or a library and didn’t find any. So even if my Google-fu is weak and there are great resources out there, now there’s another one.

The basic idea is that we take 10 samples quickly (20 ms apart), figure out the Standard Deviation, and if that’s close enough to zero, we can call this a “stable temperature.”

The full code is available from my git repository, but here’s the core of it:

  // Gather sample data

  float sampleSum = 0;
  for(int i = 0; i < SAMPLES; i++) {
    s_val[i] = analogRead(TS);
    sampleSum += s_val[i];
    delay(20); // set this to whatever you want
  }
  float meanSample = sampleSum/float(SAMPLES);

  // HOW TO FIND STANDARD DEVIATION
  // STEP 1, FIND THE MEAN. (We Just did.)

  // STEP 2, sum the squares of the differences from the mean

  float sqDevSum = 0.0;

  for(int i = 0; i < SAMPLES; i++) {
    // pow(x, 2) is x squared.
    sqDevSum += pow((meanSample - float(s_val[i])), 2);
  }

  // STEP 3, FIND THE MEAN OF THAT
  // STEP 4, TAKE THE SQUARE ROOT OF THAT

  float stDev = sqrt(sqDevSum/float(SAMPLES));

  // TADA, STANDARD DEVIATION.
  // this is in units of sensor ticks (0-1023)

So, hopefully the comments are self-explanatory (when combined with Wikipedia, if you’ve never seen Standard Deviation before.)

At the end of this block you have 2 useful variables defined: ‘meanSample’, which is the mean (average) value of all the samples you polled, and ‘stDev’ — the standard deviation amongst all the samples.

This allows you to do things like

if(stDev < TOLERANCE) {
    // reading is stable enough
    fireMissleAt(meanSample);
}

An important note about the units — the Arduino analogRead values are 12 bit, meaning they range from 0-1023.
In general, those numbers will “mean something” to you. Perhaps you can convert them to a temperature as we were doing, or a direction froma compass, or a position on a pot. I chose to do the math with the numbers in as raw a form as possible. This means that if you have a sensorToTemp() function, you can call that on meanSample, but you’d also want to call that on stDev as well. Make sure to
convert both values into meaningful values for your application. If you just want to know if the measurement is stable, then perhaps just knowing that the (12 bit) version of stDev is over your comfort level is enough.

Along with Standard Deviation came the need to print out some floating point numbers, so I also included some sample code to do that.
It’s hard coded to send things to the serial port, but could be easily tweaked to fabricate a return string or print somewhere else.

// This is a utility function for printing out floating point values
// Fixed at %0.2f form. (XX.YY, 2 digits after whatever decimal part there is.)
void printFloat(float var) {

  int int_part = int(var);
  int float_part = 100*var - (100*int_part);

  Serial.print(int_part, DEC);
  Serial.print(".");
  if(float_part < 10) {
    Serial.print("0");
  }
  Serial.print(float_part, DEC);
}

Hopefully this helps someone else out. It was fun to write and I’m sure I’ll have a use for it someday!

Photo Credit (no that’s not me!)

So, we still have shared hosting, in it’s various forms. I like the (mt) Grid Server, but I will admit to being biased (a lot.)

So with shared hosting, you don’t have root. And managing software you need (to get useful web applications up and running) can be a pain — a lot of the documentation is biased towards the idea that you have a full server, be it virtual or physical.

If you don’t have root on your server, and you’re using perl (for any of the amazing Modern Perl tools and stacks out there,) I recommend checking out the awesome local::lib.

Once you follow their ‘bootstrapping config’ and set up your bashrc, it makes things feel like you’re on your own server. Just ‘cpan -i WordPress::Post’ or ‘./Build install’, and it just works!

So a full install using local::lib would look like:
Download and unpack local::lib:
(Warning, update the link to the latest version, this is the current release:)

mkdir tmp
 cd tmp
wget http://search.cpan.org/CPAN/authors/id/A/AP/APEIRON/local-lib-1.004008.tar.gz
tar -zxvf local-lib-1.004008.tar.gz

cd into the local::lib directory, and then run:

perl Makefile.PL --bootstrap
make test && make install
echo 'eval $(perl -I$HOME/perl5/lib/perl5 -Mlocal::lib)' >>~/.bash_profile
. ~/.bash_profile

And you’re done! Every time you ssh in, your environment will be set up to use your whole local tree. So even if you want perl’s New Fancy Hotness, all it takes is:

cpan -i Moose

One caveat if you’re using local::lib and trying to run this tool from cron, is that you’ll probably want to use a wrapper script to correctly set up the environment. (Sometimes you’ll need to set up the environment for your web apps, too — that can be done via .htaccess.)

Here’s an example wrapper script, set up to work on my MediaTemple (gs) account and work with my local::lib setup:

#!/bin/bash

#set up environment
HOME=/home/12345/users/.home
eval $(perl -I$HOME/perl5/lib/perl5 -Mlocal::lib)

# run the script
$HOME/perl5/bin/mycron.pl

To make things work with your webapp, you need some ‘SetEnv’ commands in the .htaccess. You can do this by just loading the local::lib module and checking the output:

%> perl -I$HOME/perl5/lib/perl5 -Mlocal::lib
export MODULEBUILDRC="/home/12345/users/.home/perl5/.modulebuildrc"
export PERL_MM_OPT="INSTALL_BASE=/home/12345/users/.home/perl5"
export PERL5LIB="/home/68601/users/.home/perl5/lib/perl5:/home/12345/users/.home/perl5/lib/perl5/i386-linux-thread-multi:$PERL5LIB"
export PATH="/home/12345/users/.home/perl5/bin:$PATH"

Each one of those EXPORT statements needs to become a SetEnv statement.

# so this:
#export MODULEBUILDRC="/home/12345/users/.home/perl5/.modulebuildrc"
# becomes:
SetEnv MODULEBUILDRC "/home/12345/users/.home/perl5/.modulebuildrc"

Repeat that for each one of the variable ‘export’ lines, and you should be good to go! Affordable, scalable, low management overhead shared hosting and an easy way to get modern perl.

After using WordPress from both the browser and the iPhone client, I just wasn’t that happy using it for our pictures. On the other hand, we both love (and already use, and have Pro accounts on) Flickr.

Having the photos “live” on Flickr means some handy things.

1. They let you get an RSS feed of a tag. (We use ‘carterbarratt.’) This means we don’t even have to use an API key, which is convenient.
2. They always have an image available that’s sized to 500 on the longest side. This turns out to be a perfect image size (either height or width) for a lot of WordPress themes.
3. They handle video and make the thumbnails look exactly like a “non-video image” in the RSS feed.
4. Lots of things can upload to Flickr — we use mostly the desktop uploader (after exporting from Lightroom) and the new Flickr native client on our iPhones.
5. The exact same stuff (title, description) that I’d want on a photo blog is available when I upload to Flickr.

So, FlickrPress was born. It’s a fairly simple perl script, intended to be run as a cron job, which uses WordPress::Post to create new blog posts for every flickr photo it finds with a certain tag, from certain users.

Check out the FlickrPress page for downloads and installation instructions.