A side note to the attraction of file-based blog engines
One grumpy view of the attraction of 'file as blog entry' blog engines is that they are only attractive to people who don't know enough about their problems and once you come to really understand the issues you can see that they are actually a bad idea. That they are fairly popular is just because most people fall into the 'don't know enough' category and can only see the 'superficial attractiveness' of such engines.
(This should sound awfully familiar; similar things have been said about all sorts of other technologies.)
Adopting this point of view is a mistake. Regardless of any theoretical flaws that they may or may not have, it is very clear that file-based blog engines work in practice, and work well enough for people to be happy with them. Saying that such people don't know what they're missing and will regret it later is, while potentially correct, basically pointless. In this regard, good enough is the enemy of perfect and always has been.
And despite my words on the subject, I have to note that this point of view also overestimates the current practical importance of the things that file-based blog engines make difficult. Things like truly stable syndication feed identifiers and good handling of entry updates may become crucial features at some point in the future, but they are manifestly not that important right now, given that lots and lots of blogs get by fine without them. (Heck, I'm still not sure that having a syndication feed is an essential blog feature yet.)
(So, what's an essential feature? I'd say one that costs you a significant number of potential readers if you don't have it, something that has become part of the minimum accepted features of blogs for people. While I and most people I know use a feed reader, I'm not an average blog reader, so I'm not sure that feed reader usage is widespread enough in general to make syndication feeds qualify.)
The attractions of 'file as blog entry' blog engines
Despite their issues, blog engines based around the idea an entry is a file are undeniably popular (after all, I wrote one myself). Clearly there is something inherently attractive about the idea. In fact, I think there are two main attractions:
- you can do a lot of things by hand in a simple environment, starting
with writing entries. You do not need to log into an administrative
interface and start ticking checkboxes and filling in form fields;
you go to a directory and start your editor or whatever.
- the system is (or at least appears) simple and directly inspectable.
The state is immediately obvious and visible, not locked up in a
more or less opaque thing by the application. As a side effect, it
is possible to manipulate the state of the blog engine by manipulating
(I think that part of why this is attractive is that to most people, the important thing about a blog is the data, the entries and so on. Everything that the blog engine does just puts a pretty frame around the data, yet the blog engine wants to swallow up the data in the process. For your own good, of course. Honest.)
These two advantages are more or less independent; for example, it is possible to have a blog engine where you cannot hand-author entries, but the entries are still stored as plain files in the filesystem. Conversely, you could have a blog engine where you hand-wrote entries but the blog engine maintained an internal database of necessary metadata about entries that you couldn't touch.
Because the two are independent, people can have different opinions on how important each advantage is. For example, I am very attached to being able to write entries by hand but less attached to what I could call the blog engine's storage format.
Sidebar: a third attraction for technical people
Okay, honesty compels me to admit to the third attraction: if you're a reasonably technical person, the idea of a 'file as blog entry' blog engine looks pretty simple and easily to put together. (Doing a good job of the implementation is, I am convinced, not as easy as it looks.)
This makes the blog engine feel reassuringly simple and predictable; after all, it's clearly not a complex job and we could code one if we had to. In fact, any number of people do code their own simple blog engine built around this model.
I suspect that this particular attraction is more or less an accident of history, and that in the future people will be at least as comfortable with database-based technology and approaches such as Ruby on Rails.