I sometimes forget to check the site so I setup an automatic twitter feed to send me reminders. Was very easy to do …

The toughest thing about Heavens Above is remembering to check it frequently. This got me thinking – “wouldn’t it be nice if I got a text message about 10 minutes prior to a pass?”. After thinking about it and looking around on the heavens above site, I concluded there wasn’t any api or service I could coax to do this, I decided to write a quick and dirty script. I also found an blog describing some work that Paul Mison had done at Hackday London a few years ago. (I rarely have unique ideas…). The gist is this, periodically, check for ISS passes over a particular location (Richardson, Texas in this case) and within about 15 minutes of the event, send an update to twitter listing time and starting location (sky direction). I then could follow this twitter account (with mobile updates on) and now I can get notifications about when to look up and wave to our brave ISS crew (I even saw the ISS through the glare of lights at a high school football game).

The script is written in ruby and is setup to run as a cron job on one of my servers. It uses specific latitude and longitude and time zone to pull visible passes for the ISS from heavens above. It grinds up the html using Hpricot and looks for any passes with a magnitude greater then -1.0 (our seeing is better than that in Richardson but I wanted to limit the number of tweets. To reduce the number of hits on Heavens Above, the script caches the information in a config file and only returns to heavens above when it has tweeted about an event. The specifics of lat/long and twitter account are stored in a config file so this can be used for other locations as well. I’ve posted the hack on github.

If you live in/around Richardson, you can follow the richardsontxiss twitter account and it will send you tweets when you can see the ISS. It doesn’t take weather into account, but we are more likely to have clear weather than not. The next passes aren’t until the 24th so be patient if you do follow this. They do have gaps in time where there are few passes but then there will be a storm of great opportunities within a few short days.

If you are wondering what your latitude and longitude is, there is a nifty hack you can use to get it from a google map. Center the map on your location and enter the following in the browser url line:

javascript:void(prompt('',gApplication.getMap().getCenter()));

This will prompt you with the coordinates of the currently centered location on the map. Cool.

Part of the benefit of working with rails projects is the speed with which you can refactor and scaffold your way into different configurations. This can sometimes get you into trouble if an experiment or plugin doesn’t work. The best solution I’ve found for this is to ALWAYS initialized your fresh rails project into a git repository. This is like having infinite idea or skill mulligan’s for your project – a great safety net that let’s you go fast without fear.

Ryan Bates’s excellent screen cast series had a nice review of using git with rails and one of the commenters (Pete Yandell) offered a script to simplify life. This script sets up a standard rails project into git with the proper ignores. I modified the original script slightly to avoid placing .gitignore files into the empty directories within the .git directory. This is a harmless change but it seems cleaner to me. Here is my version of it:


#!/bin/sh
cat < .gitignore
log/*.log
tmp/**/*
db/*.sqlite3
coverage
doc/app/*
EOF
find . -type d -empty -exec touch {}/.gitignore \;
git init
echo "TODO - provide project README" > README
git add .
git commit -a -m "Initial import."

(here’s the gist)

This script works great (on OS X anyway) for setting up a project in git. This allows me to extend the ‘prototype’ from hours to multiple days if I need to without losing control or risking breaking the whole thing with a laps of concentration. I can create branches for experimental ideas and quickly switch back and forth. As long as my migrations are current and especially if I’m using data generators like populator, I can switch between branches to show my client a few different ideas or behaviors within seconds.

It is so great to have a (revisable) history of what I’ve done on a project. I can also quickly stash an idea away to work on it later. No matter what I do on the prototype, I can always recover back to some previous spot without much fuss or concern.

This technique works so well because it is all self contained within your rails directory and because it is such a low-overhead and fast approach.

The approach works like this:

1. rails some_new_project
2. cd some_new_project
3. git-rails
4. work on project for minutes or weeks with frequent checkins
5. create branches, rebase, squash commits, what ever – repeat previous steps
6. if want to keep it, move it to a public repo, if not simply rm -rf the entire directory…

Rails and git are really two powerful tools that have greatly revolutionized my personal work flow. I get to move quickly and with the assurance that I can undo any bad ideas. Infinite idea mulligans. I also get to practice using git even if my client is stuck on subversion (or worse). I highly recommend ALWAYS setting up your rails projects this way.