mtrichardson.com

Moving Forward in Oregon

2010-10-01T20:30:49+00:00

As you might expect, all thoughts and opinions expressed here are my own and don't reflect any position of my employer and company, Urban Airship.

It's been about sixteen months since four of us met at Bailey's Taproom and decided to go forward with Urban Airship. We had no runway and no idea if what we were going to do was going to work. We've proven the business, have hit a lot of major milestones, talk to an absurd number of mobile devices, are making some amazing technology, and have built an incredible team. All this happened during one of the worst economic depressions.

One of my cofounders Adam and myself had been laid off. We were on unemployment, which was enough to live on, but required us to be constantly looking for jobs. One of our friends, Jason, then told us about a program that's administered by the state called the Self Employment Assistance Program. The program is simple: you receive your unemployment benefits but, instead of job seeking, you work on starting your business.

Without this program, Urban Airship would in no way be where we're at now. It allowed us to focus full time on getting up and running. Without it, in those early days we would have had to do consulting or other distractions just to keep personally afloat. The business was doing great, and when the SEA ended after six months, we were able to keep going. It was, however, crucial in those early days that we focus everything we had on the company. Without the assistance of the SEA, we could not have done that.

After bootstrapping and proving the business, we received funding from True Ventures in February. We immediately started hiring. We're up to around fifteen people now and looking for more.

We're bringing money into Oregon. We're bringing jobs to Oregon. And we couldn't have done it without the SEA. It's an incredible resource and if you're unemployed and thinking about starting something new, I strongly recommend taking a look at it. Not every state does it, but yours might. I'm incredibly grateful that Oregon does.

This is where I start ranting about Oregon and politics.

Working in Oregon has a lot of advantages. Great culture, low cost living, a thriving creative environment and astonishing natural beauty all together in one place? Yes please. Oregon still has issues, however. We have lots of unemployment and people are looking at cutting basic services, like education, to help the state's financial issues. This concerns me greatly. If people are leaving because they can't find jobs, or because the state can't provide good enough education, then our talent pool is threatened and it becomes more and more difficult to grow successfully.

As a cofounder of a growing small business that's bringing jobs into Oregon, the choice is clear. We need strong leaders. We need a strong business environment and a healthy habitat for growing companies, like ours. We need to be able to easily bring in jobs, and employees, into the state, and we need to encourage more entrepreneurship and help get more small businesses off the ground. That's why I'm voting for John Kitzhaber, and why I'm encouraging you to take a look as well. Check out his closing statement from the recent debate, as it expresses perfectly why I think he's the right choice:

There's no question for me that John Kitzhaber should be our next governor. I believe he's the candidate with the experience and values to help businesses like ours get off the ground and thrive.

In the video above, Kitzhaber says that Oregon's best days are still ahead. It's a sentiment that I strongly agree with, and I feel the same way about the company I helped start. I hope you'll join me this November in helping make Oregon become an even better place to start, and grow, a company.

DjangoCon NoSQL Panel

2010-09-16T19:53:57+00:00

I was on a panel recently at DjangoCon. The topic was NoSQL in Django. You can watch it above if you'd like.

At Urban Airship we went from PostgreSQL as the data store for our most used data to MongoDB. This happened around January/February. For us, it was the quickest path away from spending all of our time fighting fires around our usage on Postgres and towards building new features. Given our set of limitations and our goals, I think it was definitely the right move. Let me be clear, however: Postgres could have done everything we needed it to. We still use it for a lot of our data. However, we didn't have the time, expertise, or money to be able to implement a good and proper postgres setup that would have alleviated our issues. Mongo was extremely quick to get up and running and handled things well until recently. It's starting to show some pains and there are some low level design decisions that impede our moving forward with it (the first point on Ethan Gunderson's recent post is the most relevant here, but isn't the only one).

Joe Stump has some flame bait-y but good thoughts around using NoSQL. As I mentioned above, a lot of it comes down to constraints.

Architecture and infrastructure is a process. It's fluid. It changes over time as your needs grow and evolve. Eventually, you figure out something that works for the long-near-term. That's about all we can ask for.

Posterous and URLs

2010-06-29T04:38:48+00:00

Posterous is a Tumblr-like service that exists to make blogging easy. Both it and Tumblr do a remarkably good job at that. Lately, Posterous has been promoting all the different services from which they allow you to import your old content. You can take an existing Wordpress blog, Tumblr, whatever kind of service out there and import all the old content into a brand new Posterous account. There is, unfortunately, a grievous problem with this whole process: URLs are not preserved.

Let's say, for the sake of argument, that I'm tired of my hacky home-grown Django blog at http://mtrichardson.com/ and that, for some reason, Posterous supports importing from it. I go through the very quick and easy process, import all my content, and then move to switch the domain over.

Except that, if I did that, every link that has ever been made to a piece of content on my blog would be broken.

The new imported content is assigned its own URL and there's no way of changing that. Since the domain is entirely under Posterous' control, I can't do any kind of normal trickery around setting up redirects from old content to new content.

In my opinion, this is very unfortunate. On top of promoting the spread of duplicate content and causing confusion among followers, it also trains us to not care about the long-term consequences of our hosting decisions. I should be able to move between Tumblr, Posterous, Wordpress, anything you want without breaking things everywhere.

That being said, I do recognize that I'm in the minority - this issue only affects people who are using custom domains already (or at least have the ability to 301 requests from the old domain to the new one). That being said - custom URLs would still be a wonderful change to see, and it would be a great feature to build into their importing system.

Edit (06/29/2010): If you normally skip the comments section of blog posts (like I do), you might want to make a special effort to check out this one. It's great to such a dedicated team behind Posterous and I can't wait to see the next features.

ZNC's partyline

2010-03-16T22:58:39+00:00

I asked around looking around for what people used for an SSL-and-password-protected private IRC network. Idan very kindly mentioned that the IRC bouncer ZNC, which we were using anyway, supports a partyline. A partyline is a private room that's on the bouncer, independent of other networks. Since our ZNC is already behind SSL and password protected, the ability to do a private room on that bouncer fits our needs perfectly.

Setting up Hudson on Ubuntu 9.10 with Apache, Django, VirtualEnv, etc.

2010-02-27T16:00:08+00:00

Hudson is the new testing hotness. It's a continuous integration server, like buildbot, except it doesn't take a ton of configuration. However, it can still take a little while to get your build system fully up and running (or at least it did for me) and I wanted to document how I did it in case other people found it useful.

First off, a bit about our system: we're a Python shop, we use virtualenv, we have a paver task to run our tests, the project is a Django project, and we use django-satprep as our test runner (mmm, nose). We use Postgres as our database, but we also use MongoDB. We also wanted to put this on a server that already had ReviewBoard on it and just have Hudson be a separate endpoint on that server. And, of course, we didn't want any random yahoo coming along and seeing how our builds were going. This is also the same server where we keep our central hg repo and while that makes some things easy, it's not required.

So, let's get going.

Installing Hudson

This was incredibly simple. Hudson has native packages for Ubuntu, so I just followed the instructions there and I was up and running. I could visit http://myserver:8080/ and see Hudson. Wow. Nice. That was it. Done.

Hooking Hudson up to Apache

Now, to get Hudson working at http://myserver/hudson. This took me a while, though it really shouldn't have. The wiki page on setting up Hudson behind Apache worked great for me. Basically, edit /etc/defaults/hudson to add "--prefix=/hudson" to HUDSON_ARGS (at the bottom of that file). I also edited it to run on port 8081 instead of 8080. Then, restart Hudson.

However, here's where the issue was: the restarting of Hudson didn't appear to really... do anything. I saw that the commands in ps aux were with the new information, but it just wouldn't take. After I killed all hudson processes with fire, and restarted Hudson, everything magically worked beautifully. So... that was fun.

At any rate, something like:

ProxyPass         /hudson  http://localhost:8081/hudson
ProxyPassReverse  /hudson  http://localhost:8081/hudson
ProxyRequests     Off

<Proxy http://localhost:8081/hudson*>
    Order deny,allow
    Allow from all
</Proxy>

and an Apache restart later, http://myserver/hudson should welcome you with open arms. Huzzah!

You can now go into your Hudson project, click on 'Manage Hudson', and give it your SMTP settings (if you want email notifications) and give it the final URL it lives at. These are both under 'Configure System'/E-Mail Notification.

Protecting Hudson

Hudson by default is kind of "everybody can do everything!" You can lock it down with user controls, but it still showed quite a bit of information that I didn't really want out there. It seemed like the easiest way to protect it would be to put it up behind basic auth in Apache. This was easily accomplished - in Apache 2.2 you can dd the authorization arguments to a definition, but I still stuck it in a block. The only trick here is that I had already enabled authentication in Hudson and the two conflicted. If you're doing auth with Apache, be sure to disable any security in Hudson beforehand. They don't play nice.

Install Plugins

Hudson comes pretty bare-bones, which is nice. The Plugin Manager is nifty - follow the 'Manage Hudson' link and then 'Manage Plugins'. I recommend the following plugins:

Bruce Schneier Plugin
Hudson Mercurial Plugin
Green Balls

Two are purely cosmetic - the Mecurial plugin is the main one that you need. The install process should work fine, but sometimes seems to just take forever and/or hang. Kicking hudson via /etc/init.d/ will fix it.

Setting up your server

This might be the longest bit, depending on your project needs. I strongly recommend using the same database that you will in production (Postgres, in our case) and make this as true to what you're going to be live with as possible. We manage settings for different environments (development, staging, production, etc.) via different settings files copied to ourproject/local_settings.py, which is then imported at the bottom of our main settings.py file. So, I created a hudson_settings.py that didn't email us on errors, but also used production-like settings. I then tested for a bit in my home directory on that machine to make sure I could check out the project from Mercurial, run our bootstrap.py file to get started (which automatically creates a virtualenv for us, installs libraries, and does a couple of other basic set up tasks), run migrations, etc., and successfully run the tests on that box (if you get failures that aren't related to your setup, great!).

Testing with Hudson

Okay, now joy! We want Hudson to automatically checkout our project, run the bootstrap file, copy over our hudson_settings.py file to local_settings.py, perform any migrations on our main database, and then run our tests. Luckily this is pretty easy to do.

On your Hudson install, click on "New Job".

Give the job a name, then choose "Build a free-style software project."

You'll be taken to the job detail screen. We're doing a Mercurial project, and a local one at that, so once we choose "Mercurial" under the Source Code Management section we enter in the path to the repo on that box. If you don't need a specific branch, just leave it blank.

Next, under "Build", add an "Execute Shell" section. This is going to look something like this:

#!/bin/bash -ex
python bootstrap.py
rm -rf bin lib include
source ./bin/activate
cp myproject/hudson_settings.py myproject/local_settings.py
python myproject/manage.py migrate
paver test --with-xunit

Update: Before I didn't have that rm -rf in there - we want that to wipe out the virtualenv so we do a full bootstrap. This will catch any libraries that have suddenly stopped working. The real solution is to have your own version of pypi.

First off, Hudson uses sh to run these by default, so we put a shebang line in there to force bash (which we need to activate the virtualenv). We copy the hudson_settings over to local_settings, migrate the database (your database should have a decent amount of realish information in there to properly exercise this step), and then test. Our paver task "test" looks like this (in pavement.py):

@task
@consume_args
def test():
    """Run manage.py tests in a more friendly manner."""
    command_list = ['python', '-W', 'ignore::DeprecationWarning', '-W',
        'ignore::SyntaxWarning', 'myproject/manage.py', 'test', '--verbosity=0',
        '--noinput']
    if options.args:
        command_list.append('--')
        command_list.extend(options.args)
    subprocess.check_call(command_list)

As you can see, it's pretty basic - it's just a friendly wrapper around manage.py test, which in turn calls django-satprep's nose test runner. However, we do tell it to do xunit - this information gets output in a nosetests.xml file, which is useful for the next step.

After we set up the script to execute on each build, check the 'Publish JUnit test result report' and enter 'nosetests.xml' in the 'Test report XMLs' section that will appear. Don't worry if it gives you a warning about it not existing.

After that, we activate Bruce Schneier, and E-Mail Notification, telling it to email our whole list if anything goes wrong.

So, great! Wonderful!

Except right now, we have to manually activate the builds. We could have it poll Mercurial every minute or so, but it's really easy to set up a post-push commit hook to do that for us.

Automatic Builds on Push

It turns out that an authenticated HTTP GET to http://myserver/job/JobName/build will start the build process automatically. We just need to write a commit hook to do that for us.

Easy!

Here's an example script, notify_hudson.py (note that we use https, you might need just HTTPConnection):

import httplib

USERNAME = 'myuser'
PASSWORD = 'mypass'

auth_string = ('%s:%s' % (USERNAME, PASSWORD)).encode('base64')[:-1]

def hook(*args, **kwargs):
    h = httplib.HTTPSConnection('myserver')
    headers = {
        'authorization': 'Basic %s' % auth_string,
    }
    h.request("GET", "/hudson/job/JobName/build", headers=headers)
    resp = h.getresponse()

if __name__ == "__main__":
    hook()

Run this to see if your build runs. If it does, then you can hook it up to your repo.

In your repo's .hg/hgrc file, put something like this in:

[hooks]
changegroup.hudson = python:notify_hudson.hook

[extensions]
notify_hudson = /path/to/notify_hudson.py

And you're good to go. When you push upstream, your Hudson build will automatically clone the project, boostrap, run migrations, and run all tests. If something breaks, it'll notify you (and once something is fixed again, it'll do that too). We'll be able to see detailed history of our tests thanks to the junit/xunit integration. It's all awesome.

pubsubsuperfeedr

2010-01-28T23:48:41+00:00

We use Superfeedr to power our RSS->Push feature. It's pretty great. We released the code we use to talk to Superfeedr. It's pubsubsuperfeedr, available now from pypi. Major thanks to Harper Reed for doing gae-superfeedr-shell which seriously bootstrapped this.

MongoDB is awesome. (Edit: not so fast)

2010-01-08T06:20:49+00:00

"...as writes occur old data will start migrating to other shards."

Thanks Adam for pointing this out.

We recently started using MongoDB at work and, I have to say, it's been an absolute dream so far.

Update: This keeps coming back to haunt me, often in humorous situations. Want to know why? Read Adam's dissection of our recent history.

PIL, libjpeg, Snow Leopard, and missing _jpeg_resync_to_restart

2009-11-21T02:02:48+00:00

I just spent a lot of time trying to get this working and I figured I should blog about this.

The Snow Leopard, libjpeg and PIL combination has a lot of issues. There are tons of blog posts out there about this, and they definitely helped get me a long way.

This blog post and http://proteus-tech.com/blog/cwt/install-pil-in-snow-leopard/ both are great for installing PIL and libjpeg, and if those work, great. You're done.

If, however, you keep getting issues after this when you attempt to import _imaging, try compiling libjpeg as i386.

When going to compile libjpeg:

CC="gcc -arch i386" ./configure --enable-shared --enable-static

And then do the rest normally, and you should be good to go.

Good luck.

More favorite tools: Gowalla

2009-11-19T19:34:36+00:00

So, full disclosure, I found out about Gowalla because they signed up to use Urban Airship. In other words, Gowalla uses Urban Airship, and I'm a cofounder at UA.

HOWEVER

That does not dilute Gowalla's awesomeness.

Gowalla is kind of like FourSquare - you check in at locations and your friends are notified that you have done so. I view these apps as an easy way to invite my friends to my location. And, yes, there is the game aspect of it. With FourSquare, you're competing on points and attempting to get mayorships. With Gowalla, you get items - beautifully done images, really - that you can swap with items at the spot you're at or others.

FourSquare has several advantages over Gowalla, such as a larger user base, restrictions to city limits (though I do enjoy seeing British friends checking in, it's not exactly useful information) and an API. However, it seems that Gowalla is working hard on these things, so I'm looking forward to them as well. Gowalla also requires that you be within a certain distance around the spot you're checking in at, which is nice.

Much like a luxury car vs. an economy car, or a Mac vs. a PC, it's the little features that are so well done that appeal to me about Gowalla. They have a great design and the app is rock solid. I'm definitely a fan.

New version of Gabble

2009-11-18T23:02:33+00:00

I figured I should probably be talking a bit more about the tools that I/we use and love.

We use Yammer at work and it's fantastic. It fills a perfect niche for sharing information across our four-person team. I've also found that Gabble is the best client for it and, as of the latest update, it solves all but one of my minor beefs with it.

It now has image viewing inline (before attachments would often get lost), it will resize the text area without bumping the text below the screen if Gabble is at the bottom of the screen (this is a complicated description, but trust me, it was annoying), and a bug fix that never really affected me.

The only thing that Gabble could fix that's bothering me right now is that it often reposts an entire day's worth of Yammer entries (I refuse to call them "yams") to Growl, cluttering that up for a bit. I think this happens when it unexpectedly quits or updates.

At any rate, Yammer + Gabble is a very nice tool.

Eric Holscher releases Kong

2009-11-18T16:52:45+00:00

Kong is a way to run automated Twill tests against a suite of existing services. Simon describes it as a monitoring tool, which I don't think is quite accurate - I'd still use monit for that. This is a step above that, doing basic integration testing on production sites to make sure that everything appears happy. I definitely see a use for this, especially when managing a large number of sites that share a code base.

FullCalendar - jQuery plugin to provide a calendar interface

2009-11-18T05:19:01+00:00

Thanks to Jacob for finding this one.

"FullCalendar is a jQuery plugin that provides a full-sized, drag & drop calendar ... It uses AJAX to fetch events on-the-fly for each month and is easily configured to use your own feed format (an extension is provided for Google Calendar). It is visually customizable and exposes hooks for user-triggered events (like clicking or dragging an event)."

This is just fantastic. I don't have a particular need for it at the moment, but it's very comforting to know that it's there when I do.

tender-multipass, Python utilities for easily integrating Tender's MultiPass authentication

2009-10-19T20:53:00+00:00

At Urban Airship, we're evaluating Tender, which is a hosted support and knowledge base app. It's done by ENTP, who are also somewhat located in Portland, OR. We were really liking what we were seeing so decided to do a spike to test it out. One of the nifty features is shared authentication - they'll delegate all auth to your existing app so users don't have to create additional accounts (this really is quite essential for something like this). Their MultiPass system is relatively easy to implement if you're using Ruby, but Python doesn't have great OpenSSL bindings - the equivalent of EZCrypto doesn't exist yet, unfortunately. So, after finally getting it working, we decided to release our code so others don't have to go through this process.

So, introducing tender-multipass, available now on pypi. The source is up on bitbucket.

As always, I had a lot of help doing this - special thanks to my Urban Airship coworker Adam Lowry, Igal Koshevoy and Evan Fosmark for this blog post for the xor stuff.

Fixing jinja2 and pycrypto (and probably others) on Snow Leopard

2009-09-07T11:28:49+00:00

I use the python.org installs for my system Python. However, these installs assume a 10.4 SDK on the system, which Snow Leopard does not install by default - it's an optional install in the developer tools installer. This causes the C bits to fail with a dramatic flourish of errors. Luckily, there are two easy ways to fix it. The first way, and probably the better one, is to just install the 10.4 SDK. If you're too lazy to hunt for your SL CD (though it's probably early enough that it's still sitting on your desk somewhere) you can modify /Library/Frameworks/Python.framework/Versions/Current/lib/python2.6/config/Makefile and replace all instances of 10.4u with 10.6.

There is no way that I figured this out on my own - the wonderful folks in #pocoo on irc.freenode.net helped me out (special thanks to mq and mitsuhiko). Also thanks to this reddit post which contained a few pointers.

(note that this is a Python issue, not a Jinja2/PyCrypto/whatever issue)

Introducing JSONP-USGS

2009-08-26T09:56:07+00:00

I've been playing around with Google Maps a bit. It got to the point where I needed elevation data, so I went looking and came across a wonderful API put out by the United States Geological Survey - it's basically a simple API for elevation. Give it a latitude and a longitude and out spits out the elevation of that point. It makes me happy that it exists.

Unfortunately, it doesn't do JSONP, which means I can't really have an interactive application that uses the elevation data - so I made a quick little Werkzeug-powered Google App Engine-hosted wrapper around it. Introducing, http://jsonpusgs.appspot.com/. Pass it a lat and lng and it'll return the elevation data in JSON. Add a callback and you have JSONP. All very, very basic.

Here's an example - click anywhere on the map and you'll get the (astoundingly precise) elevation.

Feel free to use and all feedback welcome.

Just a tip

2009-05-18T00:23:09+00:00

Don't even bother trying to watch videos and other Flash content in Firefox on OS X - Safari just works so much better.