As is fairly common, there has been a good amount of talk about how blogs manage to scale recently, and what has been interesting to see is the discussion around just what it is that is required to keep things running.
Let’s assume that you’ve decided not to go with a hosted solution, so first you’ll need a good host, and you should consider some other issues about setting up your domain too. After that, you’ll need to choose your blog software.
There are what seem to be thousands of choices, but ultimately it boils down to two: Movable Type and WordPress. Tim, among others, likes to post pictures of WordPress failing, but what isn’t often mentioned is that Movable Type can fail in the wrong situations too. Let’s see why.
Movable Type is built on Perl, which has been around for eons. By default, it is constructed on a static publishing solution. You design your site, write your entries, and then publish. When you’re done, you’re left with files on disk. This is great for performance, because most web servers excel at serving static files, but it can be a pain for you, because you may have to sit through the difficult rebuilding process, and if you get into a really bad situation, that can be a nightmare. Still, if the database goes down, you may not be able to log in, but your site doesn’t go down.
WordPress, on the other hand, is built on PHP. Its default is to provide a dynamic publishing model, where every time you request a page, it pulls the content from the database. This is great for publishers, because if you change something such as a theme, as soon as you drop it into place, it takes effect. However, if you get hit by a sudden surge of traffic, all that database activity can make your site feel the pain very quickly. That’s why being featured on Digg can get your page in someone’s stream on Flickr, like the one above.
But that’s just the beginning, because with Movable Type version 3, dynamic publishing was introduced. A PHP rendering engine came along that introduced tags that would pull your content out and publish it on demand. Every time a user hit your page, the database was queried and you now had the same advantages of WordPress. Unfortunately, the solution didn’t scale well. This could be for a variety of reasons, but mostly it’s for the same reason as WordPress – a bunch of database queries just isn’t as efficient as a bunch of static pages.
To make things even more confusing, WordPress started introducing a series of cache plugins that essentially write the database queries to disk, generating static representations of those pages. Kevin at Blogging Tips has a much better explanation of one of the latest such plugins, if you want the details. The downside is that you lose the advantage of having the “instant rebuild” feature that you once had. Those pages now need to be rebuilt, so WordPress is now even with Movable Type’s static publishing model.
Which should you choose? Ultimately that’s up to you. Movable Type has just introduced MT4 – and right on its heels, version 4.01, and 4.1 is scheduled to go into beta in the next week or so – while WordPress continues to release updates fairly regularly. The best bet may be just to try them both. There are communities around both pieces of software, and there are plugins for each as well so it really depends on which you prefer.
Since I run a number of sites off of one installation, I prefer Movable Type, but if your needs are simpler, then WordPress may fit your needs better. WordPress MU does support multiple blogs, I’m just not happy with the way that it does it. Just keep in mind that if you need your solution to scale past that single blog, or not have to install plugins to make things run smoothly, then you may want to be aware of your other options.