It occurred to me that having transitioned my blog to be a generated static site, I was paying Rackspace ~$11 to simply host static files. (And for me to have the pleasure of managing a server in the process!) This struck me as stupid, for what are probably pretty obvious reasons. So, I've made another change to my blog hosting. I'm now using GitHub Pages. Thanks to DNSimple it was drop-dead easy to change my DNS settings appropriately as well.

I've still got one more site hosted on my Rackspace CloudServer that I need to figure out what to do with. It's basically just an image server that I'm holding onto for historical reasons (there are still various sites out there that are linking to it), so I may just throw that on GitHub pages as well (it's less than 40 MB of images, so I don't feel too bad about it), though I would much rather have a solution where I could point the domain name at my Dropbox public folder for that sort of thing. Anyone know of a way to do that? I can't just CNAME the domain to dl.dropbox.com, because that would break the existing links, instead I need it to rewrite the URL to include the path to my public folder. It would be super easy to do with Nginx, but that would require me to run and manage a server, and the whole point of all this is to not have to do such things any more. Hopefully I'll be able to come up with a solution to that...

For all my non-static sites (including whatever personal and side-projects I might work on) I've been really, really happy with Heroku. If you haven't used the service I highly recommend checking them out. Hopefully I'll find the time to blog about it in more depth in the future. Suffice it to say, I will be attempting to use Heroku for pretty much every project I work on. Undoubtedly there will be some cases where it becomes necessary to manage (virtual) servers on RackSpace or EC2, but I think that's going to quickly become a small minority of cases.

Anyway, the serving landscape has been changing with remarkable speed lately, and I'm sure it will only continue to do so. The net result is that my life is much easier, and my hosting costs much lower. Vive la (hosting) révolution!

Well, I should now have a working RSS feed again. Unfortunately, I don't actually know for sure whether or not this is the case due to some complications with FeedBurner. I started using FeedBurner for this blog in 2006, well before they were bought by Google, and never really got around to doing whatever things were required when that acquisition happened. As a result, my account was never properly transitioned. I attempted to do that the other day, but it would appear that not only do I not know my FeedBurner password, I don't even know my username or the email address I used to sign up for it. Everything I tried was rejected. So, I have no way of changing my settings leaving me with a choice between changing the URL of my RSS feed (an annoying solution for my subscribers), or attempting to rebuild my new, RabbitFish-based feed in-place to keep the FeedBurner feed going. I've attempted to go with the second option, and I suppose we'll know shortly how well that worked. Looking at my server logs, it appears that FeedBurner will update roughtly every 30 minutes, so it shouldn't take too long to ascertain whether or not the new feed is working properly. I guess we'll see in about 30 minutes!

A few months ago I made some major changes to this blog. One of the obvious changes was the new design, based on Twitter Bootstrap, but in addition to that I also converted the blog from a Django site to a static site. At that point, all I actually did was scrape the site to static files using wget and throw them up on the server to be hosted with Nginx, but I've now taken that a step further.

For the past three months I've been working on a personal project named RabbitFish. It's a static site generator built on Python 3 that uses Jinja2 templates and YAML for storing configuration and content data. This blog is now powered by RabbitFish.

Largely because of the technical constraints of the still very immature state of RabbitFish, I've also made a few changes to the structure of the blog. Probably the most obvious is that I've gotten rid of the tag cloud that used to be in the right-hand sidebar. In addition, I've actually completely removed the tag system altogether. Of course, you'll notice that all the old posts, and this one as well, still have tags, but rather than being part of an actual tagging system, they're now basically just shortcuts for searching the blog; if you click on one, you'll see that it just takes you to the Google Custom Search for my blog with that tag filled in as the search query. Additionally, I've removed pretty much any way of navigating around the blog. Taking a page from Apple, I've decided to rely solely on search for finding blog posts. To ensure that all the posts get properly indexed, of course, I've also added a page that simply lists all the blog posts. (It's also linked to at the bottom of the index page.) Most of my traffic was organic search hits anyway, so I don't really see this causing any problems.

The one thing that I still have left to do is get syndication set up. Currently, the feed for everything prior to this post is still available thanks to FeedBurner, but I still need to set up a new, live feed to get new posts in there. Fortunately, that will be as easy as setting up a new ListPage in RabbitFish, and writing a template to build the appropriate XML file. I'll probably get that done this weekend.

Since I was already using Disqus for comments, all the old comments are already here and new comments shouldn't be a problem. I'm realy interested to hear what people think about RabbitFish, as well as the minimal interface I'm exposing for the blog now.

RabbitFish: https://github.com/joshourisman/rabbitfish

Backing up databases is one of those things that I've always felt could be done in a better way. Traditionally I've done it with a simple shell script that used mysqldump or pg_dump to dump my database to an SQL file named using a timestamp, compress it, and maybe scp it off to some remote server for redundancy. This approach works just fine, except that I recently took a look at my backup directory for a project using that setup only to discover that there were nearly 5000 backup files taking up 11 GB (and this is using bzip2 to compress them!). Obviously not an optimal situation, especially considering that really very little changes from backup to backup, and it's quite possible that nothing changes at all for some of them. It simply makes no sense to store an entire dump of your database every single time!

Fortunately, this is a very familiar situation that we've got advanced tools to handle: version control systems. So I decided to write a little program to replace my shell script that would use a modern, advanced version control system to provide a much more reasonable solution. What I came up with was Adamanteus, a command line program written in Python that allows you to back up your database into a mercurial repository. It currently supports MongoDB and MySQL, and I plan on adding PostgreSQL support this weekend.

Using Mercurial immediately solves basically all the problems with my original approach. It stores diffs rather than full files, meaning you aren't wasting space with a lot of duplicate information. It also handles compression transparently keeping the file sizes down even for the diffs. Plus, because Mercurial is a distributed version control system it's very easy to provide redundancy by pushing and pulling to and from remote repositories. (Pushing/pulling to/from remote repositories isn't currently implemented, but that's also in my plans for this weekend.)

The project is far from complete, but I think it's sufficiently far developed to release as 0.1. Plans for the 1.0 release include:

• PostgreSQL support
• The ability to restore your database from a particular revision in the repository
• automated cloning/pushing/pulling of the repository
• Integration with Django as a management command

Anyway, I'm definitely looking forward to some feedback on this project, as I suspect it could be quite useful to many people. Contributions are always welcome as well!

Since my last post I've seen quite a few other people writing about exactly the same issue with ObamaCare that I saw: it actually encourages people to not carry health insurance. The most recent is someone's whose blog I've been reading for a while and whose opinions I generally respect: Philip Greenspun an EECS professor at MIT. He actually did the math to reveal that a family in Massachusetts making $100,000 can expect to pay around $20,000 per year on insurance. The fine for not carrying insurance, however, would only be $2,000. And, of course, the insurance carriers would be forbidden from denying them of insurance if they showed up already sick and actually in need of health care.

But there's more! Brian Caplan at the Library of Economics and Liberty (which I don't actually know much about, but I would guess is biased in the libertarian direction from a cursory examination of the site) suggests another unexpected side-effect of ObamaCare will be that employers will stop offering insurance as a benefit. Part of the reason it's currently so common for insurance to be an employment benefit is that the government has been encouraging this behavior since around WWII by not counting health insurance as taxable income. This, apparently, is going to change with ObamaCare.

This, however, I think is actually a good thing. I mentioned in my last post that I had some ideas on a different sort of reform that I've posted about elsewhere in the past; below is an outline of some ideas that I put together a couple years ago (around the time that Massachusetts was debating the inspiration for ObamaCare):

• Decouple health insurance from employment
• current system economically stupid
• encourages un-educated consumers
• reduces consumer choice
• reduces competition in the market
• current system unnecessarily restricts consumers
• people with health problems can't change jobs for fear of losing insurance
• true cost of insurance is hidden from consumers
• Make medical costs tax deductible
• all costs should be up to 100% tax deductible (maybe variable by income)
• makes health care significantly more affordable
• provides the same functional assistance as a single-payer system
• doesn't encourage reliance on the system
• doesn't require increased bureaucracy
• encourages personal responsibility
• Provide low/no interest loads to cover medical costs
• interest rate based on need
• removes problem of non-payment
• allows even the uninsured to afford very expensive procedures
• doesn't encourage reliance on the system
• payments are tax deductible under point 2
• Loosen regulations on insurance industry
• regulations such as setting a maximum deductible hurt both sides
• consumers aren't allowed to decide for themselves what they need
• insurers aren't allowed to innovate and find new solutions
• regulations reduce competition
• not all of them!
• regulations provide a disincentive for new insurance companies to enter the market
• the more insurance companies there are, the better for consumers

Obviously this is still rather rough, and some of the points are clearly designed to address things that have now changed. However I think this is a decent outline of changes that could be made to healthcare that would meet the goals of both sides of the public/private argument. I'm sure there's tons of discussion that could be had on just about every one of my points, so perhaps I'll take the time to break each one out into a separate blog post where I can go into more detail in the future. Also, I'll try and write some more about the code I've been working on as there's some good stuff involving MongoDB, MongoEngine, and—of course—Django.

I've been generally on the fence about ObamaCare—and really about the various proposals to reform healthcare in general. I do think that our system needs reform, it's just that I've been unconvinced about the specific proposals made for the form that reform should take. But now it's 'happened' (although what we have is not really healthcare reform so much as health insurance reform) so the question is now different: what are the implications of our new system, and where do we go from here?

The implications, I think, are both quite interesting and not at all what most people expect/want them to be. For example, I think the new bill will actually increase the number of uninsured people in America (at least in the short term), and I think it will do this via two separate mechanisms:

1. An active dumping of high-cost and/or risky customers by the insurance companies who currently cover them, and
2. People taking advantage of the new system to actually save money without sacrificing healthcare by foregoing insurance

Let's look at the first mechanism I mentioned above: insurance companies actively dumping expensive patients (even more so than they already do, I mean). Starting in 2014 they will no longer be able to do this, they will have to cover everyone. But for the next four years they are free to continue doing so, and it makes a lot of sense that they would ramp up this practice so that they can increase revenues as much as possible in preparation for that future. In the meantime the government is offering some sort of high-risk pool of insurance for those people that can't currently get coverage, so it won't even seem like that bad of a deal: the insurance companies win by increasing revenue, Obama wins by being able to point to the vast numbers of people that are already being helped by the program, the patients win because they have health care, and the taxpayers win because... well, actually we don't so much... But that's really not so bad; it's hard to complain about people with health problems getting the help they need, even if you don't think they're getting it in the best possible way and you don't want to have to pay for it. It's the other mechanism listed above that I think is more insidious: gaming the system.

How and why would people game the system? Well, it's actually quite easy and straightforward: as things stand it's quite easy to get the best of both worlds: save money by not purchasing health insurance and still be able to rely on health insurance to pay for your medical expenses. The reason this work is that the 'individual mandate' of ObamaCare is toothless: just as in Massachusetts it's cheaper to pay the fine imposed for not purchasing health insurance than it is to actually purchase that insurance. $100 per year or 1% of your income (whichever is more). That's a pretty paltry fine (though it will increase in 2014 along with the activation of the various other parts of the program). And couple that with the high-risk pools that you'll be able to buy into to get government subsidized healthcare regardless of pre-existing conditions it renders this whole change meaningless (or worse?)! Why would I pay thousands of dollars per year for insurance when I can pay much less and then, if I get sick or injured, simply buy into a plan that I legally can't be turned away from? I'd end up paying less money than I would if I actually carried insurance, but I would still get all the benefits of that insurance! As long as the fine/tax for not carrying insurance is less than the cost of actual insurance, and as long as it is required by law that you be able to buy insurance at any point regardless of your current health conditions, there is absolutely no incentive for anyone to ever purchase insurance right up until the point that they actually need it!

The implications of this are quite staggering: they basically undo the whole fabric of our healthcare system. Our system (even now) is based upon the idea that it's relatively cheap to pay for routine healthcare costs, but relatively expensive to pay for the bigger and rarer procedures. So we amortize those costs over time and over a large pool of people by buying into insurance plans where everyone pays in a relatively small amount and then, on the rare occasion that they need it, they're able to draw a large amount to cover larger medical expenses. But ObamaCare has undone that! Now we don't need to pay into the system (except in a barely token amount) in order to draw from it! If and once people realize this and start dumping their insurance plans, this will lead to the collapse of the insurance industry; it will simply be impossible to operate under the insurance model.

The result of this will be greater and greater financial obligation on the government to support the insurance industry and pay for that healthcare and therefore a greater and greater tax burden on us to pay for it until, eventually, we are all simply paying taxes into a government system that funds all our healthcare needs. Sound familiar? That's because it's a single-payer system—a monstrously constructed single-payer system built with the rotting corpses of the various insurance companies.

This is, of course, a worst-case scenario. In order for this two actually happen at least one of two things has to be true:

1. Our government has to be incompetent enough to not recognize and fix these problems before they overwhelm us, or
2. The intended goal of this plan was, all along, to simply set us on the path to a single-payer system