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.