It’s hard to imagine now that early incarnations of this blog started as a Wordpress site.

Not that I have anything against Wordpress itself, as such. It’s just that I’ve developed a deep dislike for PHP (the underlying technology used to develop Wordpress). And I’m not the only one.

My brief experiences with PHP were enough to realise it’s pretty damn horrible. I feel I know enough about PHP to know I never want to go anywhere near PHP ever again, if I can help it. That thankfully short but deeply unsatisfying dalliance with PHP sent me on a search for a better match my web development desires, culminating in a much more rewarding tryst with Django, and occasional flirtations with Flask.

So it was perhaps strange that I initially considered using Wordpress for a personal geek blog. But there was some method to my madness: I actually hoped the underlying ugliness of PHP might, somewhat paradoxically, be a benefit in this case.

I’ve started blogs before, with all the best intentions of regularly writing something (anything!), but they all went no where, languishing for months without updates, then years, before eventually being scraped and taken down. But I think in those initial failed attempts at blogging I did learn a few things about myself, and the strange love-hate relationship I have with the writing process.

I realised one of the side effects of being prone to a sometimes counter-productive combination of procrastination, perfectionism and nerdy proclivities is that it’s all too easy to be distracted by things that are not actually writing. Like the blogging technology itself. Or the blog theme. Or some other technical detail. Which means a lot of technical tinkering happens, but very little writing gets done.

Not that I ever had any great ambitions as a blogger. When approaching blogging, I have set myself the ultra-low benchmark of just writing for the sake of writing. Who knows, maybe if I write enough, I might occasionally write something worthwhile. One day. Eventually. And if nothing else, there might (hopefully) be some purely personal benefit in taking the random thoughts floating around in the chaos of my mind, imposing some semblance of order and writing them down.

Regardless of whether anyone reads them.

The main thing is just to write.

Because a blog without some attempt at decent content is surely pointless. Unless you’re an internet marketer, in which case apparently content is irrelevant and it’s all about SEO tricks and link building.

But I still cling to some semblance old school ideals about aiming for at least half decent (original) content. So this time I was determined to start a technical blog and keep it going. Just my own little place on the interweb to call my own. A place to air out my half baked ideas. Which means actually writing regularly.

I actually hoped that using Wordpress would enable me to get more writing done simply as a virtue of my complete lack of technical interest in Wordpress as software, and complete disdain for PHP as a programming environment. I was somewhat naively hoping this would mean I’d be less tempted to tinker with the technology in any way, which in theory would mean I’d be less likely to get distracted from writing.

The idea was just to use Wordpress as a tool, a means to an end. All I had to do was set it up, configure it, select a theme I could live with without having to modify it in any way, and start writing.

Which is what I did. Although that selecting a theme thing took a really long time. The great thing about a mature blogging platform like Wordpress is that there are a lot of themes to choose from. The downside about a mature blogging platform like Wordpress is that there are a lot of themes to choose from. An option paralysis inducing amount. It’s hard enough to make a decision amongst so many different choices. It was even harder since I’d given myself the restriction that I was just going to use the theme as is — I was not going to waste time customising it in any way. Because customising a Wordpress theme might mean being exposed to the horrors of PHP, which is something I wanted to avoid at all cost

I should have known that was never going to happen. I set up Wordpress and finally decided on a theme. But I could not resist the urge to customise. As usual, it started by changing a thing a little thing here and there. Then before I knew it, I was knee deep in the guts of Wordpress, writing PHP code.

It was then that I decided Wordpress was not for me. If I was going to tinker, I wanted to tinker with technology I actually enjoyed tinkering with. So I scrapped the Wordpress idea and went looking for alternatives.

I found many viable alternatives in the nascent world of static site generators that were beginning to appear. Thankfully, by this time, dynamically generated, database backed blogs were no longer the only blogging game in town. By now, it seems many bloggers (especially geek bloggers) had realised that in some cases, like single author blogs not frequently updated and written by technically adept command line junkies, running a database and dynamically generating rarely changed pages for each request was somewhat redundant. Not to mention that for those of us comfortable using powerful text editors like Emacs (and even vi), typing blog entries into a tiny text box on a web page is not exactly an optimal workflow.

So there were lots of static site generators appearing. These make a lot of sense for technical blogs. Writing entries as text files in Markdown or reStructuredText format, and tracking them using a version control tool, is a familiar workflow for developers. And statically generating the blog simplifies and speeds things up immensely.

I explored what was available at the time, and the most mature at that point seemed to be Octopress. However, I’m not a Ruby guy. Yet. I like what I’ve seen of Ruby so far, and have every intention of exploring it further at some point, but for now I’m still having a lot of fun getting better acquainted with Python.

Octopress seemed to be exactly what I wanted though, with some reasonably good themes to choose from. And once again, the fact the blogging engine used technology I wasn’t very familiar with was potentially a benefit, in that I was less likely to distract myself from writing by tinkering with it. The downside of not being familiar with the underlying technology, however, is that the learning curve is much steeper, and any problems take much longer to solve. This in addition to the overhead of having to install and maintain a Ruby environment which I otherwise have no need for.

So I explored further, and found there were a few Python static site generators around, although none seemed quite as mature at Octopress. A Python static site generator would be perfect, since for starters, as a Python developer, I was already likely to have a Python development environment set up and good to go.

The three obvious choices at the time came down to Hyde, BlogOFile, and Pelican. (I realise there’s a lot more now.) I ended up choosing Pelican: I found it fairly straightforward to set up a blog, it looked like it was being actively maintained, and there was a reasonable selection of themes available.

But of course, there was no theme I was completely happy with.

Fortunately it wasn’t too hard to figure out how Pelican themes work, and hack together something more or less to my liking. What I ended up with was a hacky custom theme based around Bootstrap 2 and using Font Awesome 3 for icons. It might not have been too pretty, either under the hood or from a design point of view, but it looked more or less like I thought a blog should look, with all the common features I thought a modern blog (especially a technical blog) should have (sidebar, categories, tag cloud, decent navigation, etc). After much tinkering I got the theme to the point where I was happy enough to leave it alone and just write.

Then Bootstrap 3 was released.

Bootstrap 3 deliberately broke backward compatibility with Bootstrap 2.

This meant a substantial amount of tinkering would be required to upgrade my custom theme. One of the downsides of tinkering, and why I initially resisted the urge to customise things. Because this is what tends to happen once you start tinkering with technology. Things change, things break, things need upgrading. These things take time. Time possibly better spent writing, which is after all the point of a blog (unless you’re an internet marketer).

But I resisted the urge to tinker, and stuck with my custom Bootstrap 2 theme for the time being.

Then Font Awesome 4 was released. It also broke compatibility with the previous version.

So eventually I decided to set aside some time to work on my hacky custom theme, and update if for both Bootstrap 3 and Font Awesome 4. While I was at it, I figured this would be a good time to clean things up a bit, and try to impose some order on my previously hacky ways.

The result is VoidyBootstrap.

A deliberately generic blog theme for Pelican based on Bootstrap 3, but designed to make it easy (or at least easier) to create a customised (and less generic) look and feel.

It’s a theme that I created when I should have been writing. A theme born of procrastination.

I’m not sure if that’s a sign of my lack of discipline, or testament to my geek cred.

It’s kind of ironic that I started this blog with every intention of just focusing on the writing part of blogging, but ended up spending a lot of time messing around with the blogging engine and front-end frameworks, and ended up creating a possibly over complicated blog theme in the process.

I’m not sure if there’s a moral of the story to be found in there somewhere. Or a point to all this rambling. Maybe it’s just that hackers are gonna hack.

Maybe it was naive of me to think that I would be able to blog without getting side tracked by blogging technology and themes. Maybe I should just accept the fact that as a geek, if I’m going to be blogging, I’m not just going to be writing — I’m inevitably going to be tinkering with technical things as well. Because that’s just me.

Perhaps is just the nature of the geek beast.

And perhaps if nothing else, it shows that amongst PHP’s many failings, it’s also useless as a psychological ploy to avoid procrastination.