I pushed the initial commit for this blog on September 19th, 2013. It’s almost a year later, so it is fitting to have a moment of reflection. Over the year, a variety of interesting changes have happened both to my blog and the ecosystem on which it is built. First, let’s review the history of my blog, and then discuss events relevant to Jekyll.

Blogging in 2011

My blog began on Tumblr. It started as a blog for mionet, after which, Tumblr was briefly used to host the mionet site itself, and finally I began using Tumblr to post poetry.

However, I didn’t like Tumblr. Posting from a web interface on any site is a pain to me. I find myself writing the post in Vim, copying the finished post, and pasting it into the web interface. Not only that, but Tumblr is too complicated. I don’t understand how Tumblr works. Theming Tumblr is a complicated, horrible experience. It forces you to edit a giant CSS file in a disgusting split-screen web UI.

No thank you!

Rolling my own (2012)

Dismayed with the complexity of Tumblr, I decided to roll my own blogging software. I had a free year of an Amazon EC2 Micro instance, so I decided to put it to use. The typical LAMP stack didn’t appeal to me. I’ve never messed with MySQL, and PHP is truly disgusting. I don’t really understand how dynamic websites work, and I don’t know much about all those newfangled hipster frameworks. All I wanted was a simple static website. My EC2 instance ran Ubuntu, so I set up Apache on it and went to work. Having read Practical Common Lisp, I set out to implement a database in CL (see Chapter 3). Meanwhile, I discovered Markdown. Perfect! I could write my posts in Markdown, and let the server convert them to HTML using the reference implementation.

Ultimately, this project was not fruitful, but it did cement in my mind what I wanted out of blogging software. I wanted a simple static website that I could hack away at; something that I understood. I wanted to write my posts in Markdown using Vim.

Another issue is money. My EC2 instance was free for a year, but I wasn’t prepared to start paying for it once that year was up.

Discovering Jekyll (2013)

I read a lot of programming blogs because of r/programming. So many of these great coders have blogs, and many of them are exactly like the blog I’ve always dreamt of. What are they using? Aha! At last I found it. While paying attention to the blogs I’d read, I discovered that many of them were powered by Github Pages using Jekyll.

Starting out with Jekyll, I read through the documentation, and created the foundation of my dream blog, building off of the example site skeleton for new projects. Jekyll and Github Pages were literally all I had dreamt of and more as they were completely free, simple, easy to use, and sporting markdown posts I could write from Vim. Once I had that up and running, I migrated my poetry posts over from Tumblr.

Notable commits

Shell scripts

In order to automate the typical work-flow to blog with Jekyll, I wrote a few shell scripts, which are now on Github.

mkpost:

#!/bin/bash
set -euo pipefail
readonly IFS=$'\n\t' 

if [[ $BASH_ARGC != 1 ]]; then 
    echo "Usage: mkpost filename"; exit -1
fi

readonly file="$(date +%F)-$@.md"
cp /usr/local/share/blog/header $file
vim $file

blog:

#!/bin/bash
set -euo pipefail
readonly IFS=$'\n\t' 

if [[ $BASH_ARGC != 1 ]]; then
    echo "Usage: blog \"commit message\""; exit -1
fi

cd ~/blog
git add _posts/ 
readonly       file=$(git commit -m "$@" \
                      | grep create      \
                      | cut -sf 5 -d " " \
                      | sed -En 's/_posts\/(.+)/\1/p')
readonly      title=$(cat _posts/$file \
                      | head -n 3      \
                      | tail -n 1      \
                      | cut -sf 2 -d "\"")
readonly   category=$(cat _posts/$file \
                      | head -n 4      \
                      | tail -n 1      \
                      | cut -sf 2 -d " ")
readonly       year=$(echo $file \
                      | cut -sf 1 -d "-")
readonly      month=$(echo $file \
                      | cut -sf 2 -d "-")
readonly        day=$(echo $file \
                      | cut -sf 3 -d "-")
readonly       name=$(echo $file \
                      | sed -En 's/[0-9]{4}-[0-9]{2}-[0-9]{2}-(.+)\.md/\1/p')
readonly        url="https://miotatsu.github.io/$category/$year/$month/$day/$name"
readonly   shorturl=$(curl -s "http://is.gd/api.php?longurl=$url")
readonly      tweet="$title: $shorturl"
readonly ttytterkey="$XDG_DATA_HOME/ttytter/key"
git push
ttytter -script -keyf=$ttytterkey -status="$tweet"

Initially I used bti for twitter integration, but I have switched to ttytter. Both are actively maintained, so it is a bit of a toss-up. I prefer ttytter due to how it handles the configuration. I’ve also included url shortening for the tweets via is.gd!

Developments in the world of Jekyll

  • Jan. 24, 2014 - Added support for Sass
  • Feb. 8, 2014 - Kramdown became the default Markdown processor
    When I started using Jekyll, the new site template used Redcarpet, which I continue to use due to rendering differences between Redcarpet and Kramdown
  • Feb. 24, 2014 - New theme
    This is the theme that I’ve based the latest theme update for my blog on
  • Feb. 15, 2014 - RSS feed support is now included with jekyll
  • Sep. 5, 2014 - The Jekyll devs are letting the dust settle around the Standard Markdown controversy (discussed below) before considering adoption

“Standard” Markdown

Jeff Atwood and other interested parties took it upon themselves to create a standard for Markdown. The reference implementation and documentation do not make an ambiguous spec, and as a result, implementations have significantly diverged.

I was overjoyed when I heard of the standardization effort, but sadly the original creator of Markdown saw things a bit differently.

Technically, Standard Markdown was in violation of Markdown’s license for using the name Markdown. Gruber wasn’t keen on the idea of standardization, and naturally, drama ensued.

As a result, the project was renamed to CommonMark.

It’s a real shame that drama developed surrounding the name, because I personally really like the idea, and would like to use a CommonMark conforming Markdown processor for this blog, but that’s not going to happen for a while now, considering that the Jekyll devs were scared away.

That’s all I’ve got

It’s been a fun ride. I look forward to blogging with Jekyll for years to come, and to see how the platform continues to evolve.