I prefer to create and edit my posts in plain text. It’s a timeless format, and I find it nice to have an archive of posts lying around in plain text.

I wrote a little Python script which I used to extract an archive of my posts and pages into a bunch of files on my computer. In order to use it, you need to use “WordPress Importer” plugin. Export your posts and pages into a WXR format, and feed the file to the script.

Source code of the script is below (link for downloading the script is at the bottom of this post):

#!/usr/bin/env python

"""This script converts WXR file to a number of plain text files.

WXR stands for "WordPress eXtended RSS", which basically is just a
regular XML file. This script extracts entries from the WXR file into
plain text files. Output format: article name prefixed by date for
posts, article name for pages.

Usage: wxr2txt.py filename [-o output_dir]
"""

import os
import re
import sys
from xml.etree import ElementTree

NAMESPACES = {
        'content': 'http://purl.org/rss/1.0/modules/content/',
        'wp': 'http://wordpress.org/export/1.2/',
}
USAGE_STRING = "Usage: wxr2txt.py filename [-o output_dir]"

def main(argv):
    filename, output_dir = _parse_and_validate_output(argv)
    try:
        data = ElementTree.parse(filename).getroot()
    except ElementTree.ParseError:
        _error("Invalid input file format. Can not parse the input.")
    page_counter, post_counter = 0, 0
    for post in data.find('channel').findall('item'):
        post_type = post.find('wp:post_type', namespaces=NAMESPACES).text
        if post_type not in ('post', 'page'):
            continue
        content = post.find('content:encoded', namespaces=NAMESPACES).text
        date = post.find('wp:post_date', namespaces=NAMESPACES).text
        title = post.find('title').text
        date = date.split(' ')[0].replace('-', '')
        title = re.sub(r'[_]+', '_', re.sub(r'[^a-z0-9+]', '_', title.lower()))
        if post_type == 'post':
            post_filename = date + '_' + title + '.txt'
            post_counter += 1
        else:
            post_filename = title + '.txt'
            page_counter += 1
        with open(os.path.join(output_dir, post_filename), 'w') as post_file:
            post_file.write(content.encode('utf8'))
        post_counter += 1
    print "Saved {} posts and {} pages in directory '{}'.".format(
            post_counter, page_counter, output_dir)

def _parse_and_validate_output(argv):
    if len(argv) not in (2, 4):
        _error("Wrong number of arguments.")
    filename = argv[1]
    if not os.path.isfile(filename):
        _error("Input file does not exist (or not enough permissions).")
    output_dir = argv[3] if len(argv) == 4 and argv[2] == '-o' else os.getcwd()
    if not os.path.isdir(output_dir):
        _error("Output directory does not exist (or not enough permissions).")
    return filename, output_dir

def _error(text):
    print text
    print USAGE_STRING
    sys.exit(1)

if __name__ == "__main__":
    main(sys.argv)

You can download the script from here: wxr2txt.py.

I have a confession to make. Up until recently I did not know how to touch type. I would do what most people around me did: push the keys however which way I felt; make a typo; look down at the keyboard to find the letter I mistyped; repeat the whole process. I would put out up to 50 words per minute with this method, with an embarrassing error rate (which usually went up if I was showing something to someone). I am now terrified to think about those times.

It wasn’t until I stumbled upon Steve Yegge’s article “Programming’s Dirtiest Little Secret”, that I fully understood the implications of not developing proper typing technique.

Picture the following: programmer Clara is working in a small software company. Clara doesn’t use any fancy IDEs nor extendible editors like emacs or vim. Clara uses Windows’ default “Notepad” program to write and edit her source code. She is defending herself by saying that she doesn’t need any advanced features, and that she knows every keyword she needs to use by heart. She spends hours tediously searching for the files on her computer, opening them in Notepad, holding down arrow keys to get to whichever chunk of code she needs to edit (or even worse - lifts her hands off a keyboard and uses a mouse to navigate the file). Her editor only goes back one step with the “undo” operation… But Clara has good memory and she can re-type the code she erased.

What do you think of Clara? You might say that she is wasting her time and she should learn herself a robust editor. And of course, you will be right.

One day, Clara’s company hired a new tech lead - Jane. Jane noticed that Clara is very slow at accomplishing tasks assigned to her. So Jane showed Clara how to save a lot of time by using an advanced editor she uses. Suddenly Clara discovered a whole new world in front of her: it became much easier to read the code with parts of it highlighted, and the new text editor showed her when she would make a typo or a big error - even before Clara compiled the code. And Clara didn’t even have to re-invent the code she deleted, she could just travel down the undo tree back to the time when she erased the code: all of a sudden it felt like she had access to a time machine! Jane even told her that there are plugins which can write some code for Clara! How amazing is that? It took a while for Clara to learn how to use the new editor, but after a few months, Clara became almost as fast at doing her job as Jane. Maybe Clara even received a promotion from doing so many things in a short period of time.

If you don’t know how to touch type - you are Clara. You are wasting your time. You look ridiculous to your colleagues when you stare down at your keyboard while typing. Interviewers secretly laugh at you when you make five errors in a four-letter word. You are frustrated by even the remote possibility of having to write more than you absolutely have to.

Writing is a big part of the job as a software engineer. You write code, documentation, ask questions. Most importantly, you have to communicate with your colleagues and users. Most of this interaction is written: it’s a great form of communication for the job - written notes can be saved and searched through later. As a software engineer, you bring value to your company and its users. And due to the arcane nature of the craft, communication becomes crucial. You can be the smartest programmer in the world and you can write the best piece of software out there, but no one will know about it unless you communicate why is it so great, what it does, and how to use it.

By learning how to type properly, you turn a keyboard into an extension of your hand. All you have to do in order to type - is just think of words and sentences. Your muscle memory does the rest.

I now type somewhere between 60 and 80 words per minute with what I find to be a low error rate - and I have been touch typing now for little over a month. If you care for your craft, you have no excuse for not mastering a proper typing technique.

This is my first article out of what I hope will be many. I started this blog in 2012 and I’ve never written a single biased entry: just dry technical manuals, tutorials, and guides. This has lead to a number of page views from programmers in distress, but getting a certain amount of views was never the goal of this blog. To be honest, I am not even sure if I had a goal in mind. Everyone had a blog, and I thought so should I. I was hoping it will assist me in getting a job I will enjoy by increasing my online presence (and it may have). Maybe I was out for some online reputation and (knowing myself) fame. Of course, none of this happened.

What did happen, is that I created a collection of technical notes which no one cares about until they have a problem with something they are working on. And after the issue is resolved they close the page and never open it again, as one would do with a countless number of other programming blogs and tutorial collections.

Where am I leading with this?

Lately I have been (multiple times) hit with realization that software engineering is less about writing perfect (or any, for that matter) code, and is more about management and people skills. The very people skills most software engineers lack due to choice of profession (or maybe the other way). I spent some years reading books and articles on how to optimize, refactor, and design code for which any programmer would be praised and renowned for. I have even made some progress in reaching this “magic goal”.

Don’t get me wrong, writing readable and reusable programs is an essential part of the job, but it is only one scale on which a professional programmer’s performance is measured. And it’s a relatively small scale, in comparison to others.

As a professional, you have your skill of assessing priorities, productivity, time management, patience, an active learning process, and of course, the above mentioned communication skills. This post is about just that: transmitting ideas and concepts to readers.

I am not very good at human interaction. I am an introvert. Even worse, and as many of my colleagues do, I mumble something or smile awkwardly when passing someone in a hallway. What is the social protocol for such an event anyway? Whatever it is, I don’t think I am doing it right.

It’s hard to evaluate my verbal communication skills. Maybe people have hard time understanding the points I am trying to bring across in conversation. Being a foreigner, some people probably find it challenging to understand every word I say. In addition, with my tendency to slur words when I am tired or excited - it’s probably annoying to talk to me sometimes.

I can say with confidence that my writing skills suck. I spend by far more time than I should composing emails. I write a paragraph and then I delete it. Writing is a big challenge for me. I am quite sure this article is very hard to read. And I have a very strong feeling no one will read this article. Except for maybe, my wife - who is a fantastic writer and will point out every mistake I’ve made. This text will have to be revised many times before it becomes even slightly readable.

I started looking around for ways to improve the way I communicate my thoughts. I found a large number of articles, rules, and techniques which supposedly should instantly make you a better writer. This of course might be true if you are a professional writer or a student majoring in literature. I am neither. I stumbled upon a great article by Jeff Atwood: “How to write without writing”. Reading it gave me the push I needed to get over the embarrassment of the inevitable failure from writing poorly. And I know I am writing poorly, I’ve read the stuff I wrote.

You don’t expect yourself to wake up one day and write awesome code, do you? No, you wake up, go to work, fail, and maybe after months and years of practice you become better at putting together pieces of code. The same rule applies to writing. Write a lot and often, and read what smart people write. Try to be even better than them. Fail. Repeat.

This is why I am starting to write less technical entries. Abstract topics will let me hone my writing skills. All I have to do is just stick to some sort of a writing schedule. I’ll come up with things to write about, I am a pretty loud person.

P.S: My recently acquired touch typing skills have come in handy in composing this. I would have previously never had the patience to finish the wall of text I am looking at right now. Go learn to type faster.

There was a recent fantastic addition to Python 3.4 by Raymond Hettinger: contextlib.ignored. It’s a context manager which lets you shorten the following often-occurring pattern:

try:
    os.remove('i_probably_do_not_exist.txt')
except OSError:
    pass

And turn it into this:

with ignored(OSError):
    os.remove('i_probably_do_not_exist')

Much shorted and prettier. But, as probably most of engineers, you have to use older version of python in production. That’s where this little chunk of code comes in. Create a little compat (as in “compatibility”) library and add following function:

import contextlib

@contextlib.contextmanager
def ignored(*exceptions):
    try:
        yield
    except exceptions:
        pass

Beautiful!

UPDATE: As Andy pointed out in comments, this context manager has been renamed to contextlib.supress (https://bugs.python.org/issue19266).

I have been using Mutt for a while now. Wouldn’t say that it saves my time, but nor does it extend the amount of time I spend reading email. For me, the best part about Mutt is that it lets me use text editor of my choice - Vim. Everything else - keyboard shortcuts, minimalist design, and simplicity - already exists in Gmail.

I found configuration below to work really well for my needs: all of the important for me Gmail features are translated. Here’s my .muttrc file:

bind editor <space> noop
set alias_file        = '~/.mutt/aliases.txt'
set copy              = no
set display_filter    = '$HOME/.mutt/aliases.sh'
set edit_headers
set editor            = "vim +/^$ ++1"
set folder            = "imaps://imap.gmail.com/"
set hostname          = "gmail.com"
set imap_check_subscribed
set imap_pass         = "$PASSWORD"
set imap_user         = "$USERNAME"
set mail_check        = 5
set move              = no
set postponed         = "+[Gmail]/Drafts"
set spoolfile         = "+INBOX"
set text_flowed       = yes
unset imap_passive
unset record

# Gmail-style keyboard shortcuts
macro index ga "<change-folder>=[Gmail]/All Mail<enter>" "Go to all mail"
macro index gd "<change-folder>=[Gmail]/Drafts<enter>" "Go to drafts"
macro index gi "<change-folder>=INBOX<enter>" "Go to inbox"
macro index gs "<change-folder>=[Gmail]/Starred<enter>" "Go to starred messages"
macro index gt "<change-folder>=[Gmail]/Trash<enter>" "Go to trash"
macro index,pager d "<save-message>=[Gmail]/Trash<enter><enter>" "Trash"
macro index,pager y "<save-message>=[Gmail]/All Mail<enter><enter>" "Archive"

source $alias_file

It is quite self-explanatory, and includes such nice features as:

  • Automatically adding addresses from read emails to address book (see below).
  • Using vim as a text editor, with an ability to edit message headers/recipients from within vim.
  • Ability to access all the default Gmail folders: All mail, Drafts, Inbox, Starred, Trash.
  • Key bindings to delete and archive messages bound to d and y respectfully (I am a huge fun of a zero-mail inbox).

You might also want to have your password encrypted by GPG as opposed to leaving it in plain text in your .muttrc file. You can read how to do this here: Using Mutt with GPG.

As you may have noticed, .muttrc above sets display_filter to $HOME/.mutt/aliases.sh. This script is being executed every time you read an email, and it collects email address to $HOME/.mutt/aliases.txt. Contents of the aliases.sh are below:

#!/bin/sh

MESSAGE=$(cat)

AWK='{$1=""; if (NF == 3) {print "alias" $0;} else if (NF == 2) '
AWK+='{print "alias" $0 $0;} else if (NF > 3) {print "alias", '
AWK+='tolower($(NF-1))"-"tolower($2) $0;}}'

NEWALIAS=$(echo "${MESSAGE}" | grep ^"From: " | sed s/[\,\"\']//g | awk $AWK)

if grep -Fxq "$NEWALIAS" $HOME/.mutt/aliases.txt; then
    :
else
    echo "$NEWALIAS" >> $HOME/.mutt/aliases.txt
fi

echo "${MESSAGE}"

This script will create aliases.txt file containing email addresses for search and auto completion of email-addresses.