It's been far too long since I wrote anything on this blog, so I'm easing myself back into it with what I've found to be a nice shortcut over the last few months. It uses one of my favourite POSIX tricks - symlinks to executables, together with behaviour based on the original symlink's name - the 'zeroth' argument to the executable.
As someone who identifies fully - and then some - with this xkcd comic: The General Problem, I would really rather not have to type commands which require options. I like aliases, preferably one or two characters long, and I would prefer to write one long word than a short word with an option or two. The mental effort of typing a single word to do a specific action is exactly what I want.
Which leads me to the problem. Text files are great. I am (or was) regularly opening editors, making notes, and saving them somewhere random. The problem is that, like standards, there quickly become too many of them. Which one to use? How to keep track of them? The problem is that the action 'edit my notes file' has to be split into two: a 'verb' (edit), and an 'object' (that particular file). Now you might think I'm irredeemably lazy, but that's twice as many things to remember - or type - as I'd like. I could just add an alias to .bash_aliases, but that's no fun, and while I could have a bunch of them, if I wanted to do anything more complex, I'd be repeating myself too much. Laziness, remember? Got to solve 'The General Problem', and then never have to worry about the specifics ever again :-)
One of my fun projects many moons ago was about adding '--xml' options to ordinary posix commands (xmlcmd - because XML may have serious backing in the enterprise, but needs all the help it can get to make this 'the year of XML on the Linux desktop'), and in it I create symlinks from ~/bin/name-of-posix-command to a Python script which then looks up and runs the original command (using the Python which package), before encoding that command's output into XML to be returned to the user. So basically:
- Symlinks in a path early in $PATH to a common script
- Use of
argv[0]/$0in that script to know from which command it was called, and act accordingly.
(And which ls on all my computers still shows $HOME/bin/ls, even though I hardly ever use the --xml option - isn't transparency nice?)
Applying these techniques to the rather simpler - yet more useful - task of editing files, and jumping to the punchline, I have this in ~/bin/editfile:
#!/bin/bash
EDITFILE_DIR=~/Dropbox/editfile
mkdir -p $EDITFILE_DIR # ensure this exists
TARGET_PATH=$EDITFILE_DIR/$(basename $0).txt
case $1 in
'-a')
# append command arguments to file and exit
shift # don't include the '-a'
echo "$*" >> $TARGET_PATH
;;
'-l')
# list file and exit
cat $TARGET_PATH
;;
*)
# Determine editor to use
if [[ -n "${EDITOR}" ]] ; then
EDIT=$EDITOR
elif $(which gedit) ; then
EDIT="gedit -b" # default fallback if present
else
EDIT="vim" # fallback if no gedit there
fi
# Edit it...
$EDIT $TARGET_PATH
;;
esac
And this:
$ ls -l ~/bin -rwxr-xr-x 1 ben staff 714 28 Jan 23:55 editfile lrwxr-xr-x 1 ben staff 8 19 Dec 22:13 notes -> editfile lrwxr-xr-x 1 ben staff 8 19 Dec 22:50 report -> editfile lrwxr-xr-x 1 ben staff 8 19 Dec 22:50 todo -> editfile lrwxr-xr-x 1 ben staff 8 19 Dec 22:50 track -> editfile
This has been developed from the much simpler starting point which looked something like this:
#!/bin/bash gedit ~/$(basename $0)
The result of this is that I can type 'notes' from anywhere on my system, and up will pop my editor with the notes file, which happens to be something on Dropbox, and therefore available on all my computers. I can add as many extra files for different purposes as I like, and they all act in the same way. The files themselves aren't tied into any particular system, and even have helpful '.txt' extensions on the 'actual' files. And since there's a single script behind all of these, they all inherit the 'extras', such as '-l' to list the file, and '-a' to add a line, and I can add extra features and commands, and only have to do it once.
But the main point of all of this is that I've turned a verb + object into a more specific verb, and as long as the first verb is something like 'edit this text file', then I've solved The General Problem too. It might have taken a while longer than 'alias notes="vim ~/Dropbox/editfile/notes.txt"', but that wouldn't have been half as fun. And if you haven't looked at the xkcd comic I linked to earlier, you should now... :-)
I feel the need for a 'today' action, and while I'm at it I should add a todo:
$ (cd ~/bin; ln -s editfile today) $ todo -a blog post about recently released pylibftdi 0.9
, which contains chapters on Text, Regular Expressions, Binary data (rather a short ad-hoc chapter), XML, and Relational Databases. Perhaps the 'binary data' chapter is short because there simply aren't many patterns available. There is no language to describe unabstracted data. And perhaps when we consider the data layer we should be using, we should think not only of features and performance, but also the power, expressiveness, and concision of the languages available to reason about the information. Perhaps too often we settle for a lowest common denominator solution (text) when a higher level one might be more powerful, especially if we don't have to give up on the concepts of fine-grained interoperability which micro-DSLs such as XPath give us.