tadhg.com » writing

Perfectionism is Hard

Tadhg — Tue, 31 Aug 2010 06:50:46 +0000

I haven’t been that happy with my blog posts recently. It’s not that I think all of them are terrible, or that the quality suddenly dropped off a cliff, but I feel as if there’s been a decline. It’s tough to measure this, of course, with no clear criteria. But that I feel this way is indicative of some problem.

At the same time, I feel as if I haven’t been writing what I want to write, mainly because I’ve shied away from a lot of topics that I’ve wanted to write about.

The general pattern is that I think of something I want to write about, something I usually either feel strongly about, or want to work out my thoughts on, or both. Then I think it over for a little while and come up with some ideas on how I’ll approach it as a post. Then it comes time to write the post, and I resist writing about that topic. Usually because I feel that it will require too much time, or too much effort, or both, to do it justice. So then I try to write about something else instead, something less demanding.

The subsequent search for the less demanding thing often takes more time than writing the original post would have. Occasionally I end up writing about something else equally demanding, which is fine, but usually I find something brief and light instead.

There’s nothing wrong with brief and/or light posts. But there is something wrong with writing them because I’m avoiding writing about something else. Even more so when that something else is actually a topic I want to write about.

I want to write about it, but somehow this desire moves into the realm of theory, and instead of being a motivating force becomes a heavy weight, having undergone the deadening transformation from “want to write” to “should write” to “should already have written”.

That description skips a step, the critical one where the desire to write dissipates but the loyalty to the topic remains. I suspect that this step has much to do with placing high expectations on the finished product.

Originally I was going to title this post “Writing is Hard”, but while that may certainly be true, the current title is more germane. It’s not writing per se that I’m having trouble with, it’s writing in the shadow of my expectations. It’s grappling with the fact that some part of my mind has already calculated (using unknowable metrics) how “good” the post “should” be, and some other part of my mind then blanches at having to meet this standard.

This is perfectionism, hiding in plain sight, masquerading, as it often does, as a heartfelt and genuine concern for quality—not just quality in terms of what the output is like, but of course also the quality of my writing experience, for it feels that it would be terrible if I inadvertently got into the habit of not giving my all to topics I write about. That, it says, would be tragic. That would be a terrible waste, as I would then have not just shitty output but a shitty process as well, the worst of all worlds.

By some remarkable coincidence, the presence of this perfectionism has helped me to my current point, where I’m concerned about… shitty output and a shitty process.

Even after more than four years of regular public writing, a practice I took up in large part to try to get past the perfectionism that I felt was holding back my writing, I still appear to have a lot of difficulty trusting myself enough to just let go and write about whatever interests me. Perhaps the most insidious thing is that this perfectionism creeps in partly by way of my pride in the pieces that I regard highly. After all, if I’ve written them, it’s clear I can achieve a high standard, so less would be a failure.

One of the reasons I write this blog is for practice. Practice so that I can be a better writer. It’s definitely helped, but practice, mere activity, isn’t enough—to really improve, one needs “directed practice”, which I haven’t seen clearly defined anywhere but which I think I understand. It takes a certain focus, a focus that is not always easy to summon. In the time I’ve been blogging, I think I’ve done that for concentrated periods, but I (clearly) haven’t managed to make it properly habitual.

In terms that will sound awfully self-helpy, I think that almost any conscious concern with the quality of the product of the endeavor is counterproductive. At the same time, concern with the quality of the process is quite important. On top of that, though, this concern with the quality of the process cannot be allowed to silence the writing voice. The writing voice must be heard, and respected, but with a recognition that when it drifts away, or goes silent, the conscious mind will do its best to take over and will respect the intent of what that voice was trying to achieve.

If this sounds like vague and unverifiable crap to you, well, it sounds that way to me too, but with an additional maddening conviction that it’s extremely important. There is a balance that must be struck here, and describing it may be even harder than striking it. For me, I tilt so far to the side of inner editorial control that some of that will always be present even when I try to just “write free”, and so my worries about somehow disengaging too much are unrealistic to say the least. Furthermore, I need to keep in mind that even if ninety, or ninety-five, or even ninety-nine, percent of what I write here is crap, that will still result in a few good posts per year, which is infinitely better than none. This is not a new thought, but it is one that I need to remind myself of, and to explicitly write out.

It’s not as simple as just writing what I want to write about. But writing about the things that I’ve recently wanted to write about would be fine, far better than my current approach of letting the ideas die, their dead weight immediately landing on top of new ideas, gradually making creativity in general much more laborious. This is how perfectionism makes things hard—not just in an exacting and demanding and up-front way, associated with much editing and rewriting until things are just so, but also in subtly making creativity and self-expression far less appealing, far less fun.

Tags: Blog, personal, writing

Three Routines

Tadhg — Mon, 02 Aug 2010 17:22:10 +0000

I don’t tend to think of myself as a particularly disciplined or organized person, a view often at odds with how others perceive me, but I will admit to liking to organize and order things in specific ways. This may be related to my left-handedness, and/or to my attraction to precision (which attraction falls short of achieving precision, although I hope that in language I occasionally come close).

I still struggle, as do most people, with trying to focus on the right things, to not become wrapped up in getting perfectly right things that just don’t matter. Without getting into what matters and what doesn’t, it seems to me that the last twelve years of my life have involved a significant amount of progress in this struggle, and that I’ve learned to route some of what might loosely be termed “OCD” (or OCPD, although in truth I don’t have either of those disorders) into fairly productive channels.

Before the age of twenty-four, I was never able to stick to a routine that wasn’t forced upon me. I’d tried and failed many times to follow daily routines, especially with exercise. Doing something regularly every day, or even a few times a week, seemed impossible.

That’s changed. I continue to struggle with being productive—two novels in various stages of incompletion, and a considerable pile of other unfinished projects, make this abundantly clear. But aside from working (which, no matter how much I enjoy it, is a routine pushed upon me by outside forces), I now have three things I do almost daily that are quite important to me:

Morning pages. It’s more than twelve years, now, that I’ve been doing these every day. They’re simply part of daily life, and will continue to be so.
This blog. I’ve been blogging either daily or five times per week for just over four years. It’s not part of daily life in the same way my pages are. Writing my blog posts still feels like an imposition some of the time, and it’s often a struggle. I sometimes feel it as a real strain, the requirement of coming up with five things to write about every week, and experience my two days off as almost like vacations due to the relief of not having to deal with that. I occasionally have to remind myself that I have opportunity to express myself in any way I choose, on any topic, in a public way unavailable to anyone who lived in the pre-Internet age, and that this makes me incredibly lucky. Of the three near-daily things, this is the one that feels most fragile, most susceptible to my (likely mistakenly) deciding at some point that I don’t need to keep it up.
CrossFit. I’ve been doing it for more than a year, and it hit a critical level quite some time ago, so I’m quite sure I’ll keep going with it. This is pretty clear from the fact that last week I did a ton of travelling, lost a lot of sleep, and was generally all over the place, but still managed to do CrossFit workouts five days out of the seven (five is my target every week).

While I don’t think I ever really exhibited a lot of compulsive behaviors, those I did have largely been refocused into this triumvirate. I still perceive the setup I’ve created for the latter two: I’m consciously pushing the idea that sticking to those routines is an achievement, and that there’s a kind of invisible checkbox for each of them in my mind, with a psychological payoff every time the tick mark is entered. The latter two have a public aspect, also, in that posts are public and that I log (and broadcast) my workouts, and this public aspect is a further motivator.

It’s a powerful trio of habits. My morning pages are (obviously) introspective outlets, a kind of dialogue with myself that has a dedicated place in my life every day. My blog posts are public self-expression, writing that has some degree of polish and with which I (hopefully) hone my ability to make myself understood. I’m very used to the rhythm of it, Sunday/Monday/Tuesday/break/Thursday/Friday/break, and while I sometimes worry about complacency and conservatism in my posts, I’m nevertheless convinced that it’s incomparably better than not doing it. CrossFit is the first regular exercise I’ve managed to stick to in my life, and has done me tremendous good. Its rhythm isn’t as set, as my target is to fit in five workout days per week any way I can, and by its nature it’s more susceptible to disruption (by wisdom tooth extraction, for example); I’m more willing to accede to lapses in the routine.

Introspection, self-expression, and intense exercise. Not a bad three things to have running smoothly. That’s not self-satisfaction speaking—in many ways those three things barely constitute a viable starting point for what my adult life should be—but rather recognition that I’ve managed to work out some of the things that seemed insurmountable in my early twenties.

Tags: Blog, CrossFit, exercise, personal, psychology, writing

How to Cheat in the Leaving Certificate on YouTube

Tadhg — Tue, 06 Jul 2010 04:03:46 +0000

Some time ago I wrote a feature film with Graham Jones: How to Cheat in the Leaving Certificate, a heist movie about the Irish education system. It is now available on YouTube.

I’m leery of YouTube as a venue for feature films, since it’s geared much more towards short clips. On the other hand, if the film is insufficiently gripping, that’s down to mistakes we made.

The film has been in the news again recently, mentioned in stories concerning allegedly widespread cheating.

I’m amused that one of the primary funding sources for the film was the now-nationalized Anglo Irish Bank.

Tags: education, film, personal, writing

Original Draft of The Empire Strikes Back

Tadhg — Tue, 01 Jun 2010 06:27:47 +0000

Here’s a review of the original draft. It’s my favorite of the films, and finding out it was the least successful one made me sad. The original is interesting, although probably inferior to the final film—for example, giving Han a father (or any family) would have weakened his character.

Tags: film, writing

sabbatical.close()

Tadhg — Mon, 17 May 2010 06:36:56 +0000

After a highly enjoyable, productive, and extended period, it’s time for me to return to the world of paid work.

I’m quite happy with the things I’ve done during my time off. Many of them are important only to me, but then, it’s been my time off.

Here are some of the things I’ve done since leaving Metaweb that I consider significant:

CrossFit. I’m approaching the one year mark, and it’s hard to overstate the importance of that for me. This is the first time in my life I’ve managed to keep an exercise routine of any kind going for that long. Not coincidentally, I’m also in the best shape of my life. I now feel that some kind of regular, intense, exercise has a similar place in my life to my morning pages—that is, something I I regard as mandatory and more or less permanent.
Diet. Not just switching back to eating meat, but also radically cutting down on sugar and processed foods. This also has a lot to do with my being in good shape.
Document format. Until this year, I hadn’t found a text-based document format I liked, but I have now finally settled on reStructuredText. One of the effects of this is that I shifted to doing all of my writing in a text editor rather than doing some of it in word processors. Another effect is that all of my writing is now much more amenable to programmatic manipulation.
Programming my own environment. Following from the previous item, I spent quite a bit of time working on solutions to various small niggles in my workflows, so that far less of my time is consumed by setup for writing. Some examples of this include scripts to insert the template for blog posts into my editor, scripts to publish to my blog directly from my editor, scripts to do word counting precisely as I wish it to be done, and many other small utilities that remove minor annoyances that I previously encountered almost every day. In many respects this kind of thing is precisely what programming and computers are for: to make it easier to create, and to lessen the gap between a thought and expression of that thought.
Digital organization. This includes recovering my subversion repository, restoring my blog to proper working order, and various other steps that have made my digital domain much more manageable. This is bound up with the previous item too.
Switching to Vim. This was probably a long time coming, but nevertheless required a fair amount of work, not least in porting all my scripts for jEdit over to it. I’ve been extremely happy with Vim. I think that to most people this might sound trivial; how many people would regard switching word processors as an “achievement”? But a text editor is different from a word processor, and switching to Vim isn’t like switching between non-modal text editors. This, combined with moving all my writing to text editors and thus to Vim, is a profound change for me, and one that I’m very happy I took the time to get through.
WordPress plugins. I wrote some of these to improve my blog after I got it working again.
PyWordCount. My word counting script/Vim plugin is done, but I have to finish the documentation for it and make it public. It’s significant to me because it’ll be my first self-contained public Python project, and also because it’s an outgrowth of the document format switch, the Vim switch, and the focus on programming my own environment to a much greater degree.
Q’Rith. I ran my first roleplaying sessions in 15 years, and am currently running my first roleplaying campaign in 15 years, in a world that I’ve created and am quite happy with so far.
Tennis. I started playing it again, and don’t know why I ever stopped.

Those are the main highlights. Many of them are internal, or are things that only I notice, but I think the effect they’ve had on me is actually quite major, and in positive ways.

As for what’s next, I’ll write about that tomorrow.

Tags: coding, CrossFit, diet, document formats, exercise, food, games, goals, personal, python, reStructuredText, roleplaying, software, sports, T, tech, tennis, text editing, version-control, Vim, WordPress, writing

Improving a Python Word Counting Function

Tadhg — Thu, 29 Apr 2010 20:33:36 +0000

This post could be summarized as “regular expressions are a lot faster than naive for loops”.

I’ve been working on improving the script I use for live wordcount in Vim, partly for performance and partly so that I can package it up as a plugin and share it with other people. Along the way I’ve improved the speed of the script rather significantly, and will go through the key part of that change here.

The core part of the script, unsurprisingly, is the count_words() function. As is common, it treats groups of letters surrounded by spaces as “words”. New lines also mark the end of a word. So do a variety of other characters, such as em dashes—in fact, one of the motivations for writing my own wordcount was because I wanted em dashes to be recognized as word separators.

In the following code, self.WORD_SEPS and self.LINE_SEPS are lists containing characters that separate words and lines. self.REPEATER_SEPS contains characters like “-”, which in my opinion does not separate words when used singly (e.g. “twenty-three” is one word) but does when used consecutively; “–” is a simple way to write an em dash when you’re restricted to ASCII. self.IGNORE is a list of characters that cannot form words on their own but aren’t necessarily separators, either.

The code is quite naive in its approach. It goes through the text letter by letter, checks the letter to see whether or not it’s in one of those lists, adjusts the count accordingly, and also stores previous_char in order to be able to handle the repeater separators.

def count_words(self, text):
    words, lines = 0, 1
    word, previous_char = 0, None
    lineword_separators = self.LINE_SEPS + self.WORD_SEPS
    repeater_test = lambda c, pc: bool(
        c in self.REPEATER_SEPS and pc in self.REPEATER_SEPS)
    separator_test = lambda c, pc: bool(
        char in lineword_separators or repeater_test(c, pc))
    for char in text:
        if separator_test(char, previous_char):
            word = 0
            if char in (self.LINE_SEPS):
                lines = lines + 1
        elif char in (self.IGNORE):
            pass
        else:
            #it’s part of a word.
            if not word:
                words = words + 1
                word = 1
        previous_char = char

    return (words, lines)

With that code as the central function, the script takes about three seconds to process a text file that’s approximately 400K/68,000 words.

The new version eliminates the need for a separate list of repeater separators, is fewer lines of code, and is faster:

def count_words(self, text):

    def ors(l): return r"|".join([re.escape(c) for c in l])
    def retext(text, chars, sub):
        return re.compile(ors(chars)).sub(sub, text)

    lines = text and len(re.compile(ors(self.LINE_SEPS)).split(text)) or 0

    text = retext(text, self.WORD_SEPS + self.LINE_SEPS, u" ")
    text = retext(text.strip(), self.IGNORE, u"")
    words = text and len(re.compile(r"[ ]+").split(text)) or 0

    return (words, lines)

The basic approach here is different. Rather than going through the text and evaluating it character by character, instead it replaces all of the characters in the separator lists with spaces, removes all the characters in the ignore list, uses split() to get a list of all the words in the text, and then counts the length of that list.

The most awkward part of it is having to construct the regular expressions out of the lists of characters, which is what the ors() function does. I could have replaced the lists with regular expressions, but I want it to be easy for users to alter the lists to suit their own preferences, and so left them as plain lists.

(Note that I’m restricted to Python 2.3 here since this needs to run in MacVim; hence the old-style and and or instead of new-style ternary expressions.)

Using that code instead of the previous version, and operating on the same 400K/68,000-word file, the script takes about 0.12 seconds—a 25-fold speed increase. Since this is a “live” wordcount, one that has to recount the entire file whenever you do something other than typing or adding a single new line, that’s an important difference, and it makes it much more usable when working with large files.

I had no illusions that my original version was anything close to optimal when I first wrote it, but I didn’t realize that the speed gains from doing it better would be so significant. Python’s regular expression handling is done by a C module, and I suspect that C module is quite highly optimized indeed. So, if speed is important, let highly-optimized C do the work, instead of doing it in your own code.

Tags: coding, python, software, tech, text editing, Vim, writing

“Wandering Mind”

Tadhg — Mon, 19 Apr 2010 06:57:55 +0000

The mind wanders around and around. It might be in a maze, for often the spaces look eerily familiar. The paths seem different, the distinction between path and destination murky.

The quest is for something new. Something that seems perfect for a brief bright glowing moment. Something that looks fascinatingly full of potential, potential shaped enough to snare but not so shaped as to dismay with specifics.

The mind yearns for such an encounter, for the bliss of absorption, challenge, and distraction all rolled into one. For the absence, or at least recession, of worry and stress and anxiety during consumption. For the fleeting brush with the possibility of fulfillment.

Which branch to take? They begin to seem well-worn, uncomfortably familiar, and the things on them re-treads of old concepts. Where is the new thing, the exciting thing? Where is the alluring fruit of others’ creativity—creativity attuned enough but not too closely with the mind’s own?

If it’s not there, what about there? Or perhaps within. Within, but not too far down. Again, the mind seeks a balance: not something on its own surface, for its own surface is too well known to it, but not something deep inside, for the muddle there is daunting. Between these must be something shiny and shining, something with at least the appearance of profundity.

Profundity, and novelty. Novelty, and cleverness. A sufficient challenge to mine and shape without making either of those things arduous.

There. A half-formed idea, one that can be brought into a pleasingly new form, near the surface. Both its formation and its output will be superficially challenging, enough to briefly satisfy. The mind digs, prods, shapes, has its moments of forgetting itself in the process.

Something new, briefly brightly aglow with potential.

The mind wanders around and around.

[300 words]

Tags: fiction, microfiction, writing

Refactoring, Geeky Enjoyment, and Readability

Tadhg — Mon, 05 Apr 2010 20:16:55 +0000

Refactoring is rewriting source code while preserving the functionality of that code. I’m currently refactoring my Python script for Subversion status, because I want to experiment with sharing code on bitbucket and it seemed like a reasonable first project to put up there.

Some people hate refactoring, but I often enjoy it. I get a kick out of figuring out how to make code “better”, although that’s often a subjective judgment. In this case, when I opened up the script to have a look at it, I immediately saw a function that I knew I wanted to refactor. I’m amused by the enjoyment I derived from making the fairly simple change.

The function gets the length of the longest filename in a list[1], returning 0 if for some reason there aren’t any filenames in that list. This was the original version:

def get_filename_width(self, files):
    width = 0
    lines = files.split("\n")
    for line in lines:
        if len(line) > width:
            width = len(line)
    return width

It expects the files variable to be a multiline string. So it assigns a value to width, then splits the string into individual lines, and goes through each line, testing its length against the value of width and making width into that value if it’s greater. After going through all the lines, it returns width.

It’s fine as a first pass, but looking at it now, it just seems clunky and too long. I rewrote it into this:

def get_filename_width(self, files):
    return max([len(line) for line in files.split(u"\n")]) if files else 0

Six lines into one. But is this too opaque?

If I’m the intended reader, clearly not, as I’m quite familiar with reading list comprehensions, and I also consider the Python 2.5+ ternary expression to be entirely legible.

If someone else is the reader? The ease with which they can break the line into chunks is the main issue, as first they have to see that the line returns the result of max() if files has some value and 0 otherwise. The next bit is seeing that max() operates on a list comprehension, and finally they have to see that the list comprehension creates a list of the lengths of the lines in files.

I can see the argument that the six-line version is clearer, but the fact that it’s six lines as opposed to one needs to be taken into account as well—more lines mean more cognitive overhead for the reader, something that is often underestimated in judging the readability of code.

I think that a reader familiar with Python would grasp the one-liner faster than the six-liner. The use of max is helpful here (whereas it might hinder a reader who doesn’t know it)—rather than having to discern what the for loop in the six-liner is doing, it’s clear that the one-liner is interested in getting the highest value. I personally think that the lack of variable assignment in the one-liner makes it easier as well, despite the familiarity that almost all readers would have with variables.

Clearly, this is a rather trivial example[2]. But the issues are relevant to writing shared code, and “shared” often applies even to personal code if you’re ever going to revisit it. While I definitely want to get something working quickly, it’s important to balance that with writing readable software. Readability requires finding the line between elegance and impenetrability, between concision and obscurity—just like writing more generally.

[1] Yet it’s called get_filename_width—because it’s concerned with the width (in columns) that the longest filename will take up in a terminal window. The purpose of the function in the larger context is related to the concept of width, while in the function itself it’s dealing with the length of individual filenames. You could argue for changing the name to get_filename_length, but I think the overall purpose of the function is more important to its name than what it’s doing internally.

[2]	It took me less than 3 minutes to write the new version of the function, whereas this post discussing it has taken rather a lot longer than that…

Tags: coding, python, writing

Anaq’rest

Tadhg — Thu, 01 Apr 2010 19:56:45 +0000

At the beginning of March I kicked off a roleplaying campaign, the first I’ve run since early 1995. The setting is essentially the one I laid out last year in my fantasy world sketch, which now as the name “Q’Rith”.

Technically the first game set there was the one-shot I ran in December, but in certain ways it could have been set anywhere. The campaign is more tied into the politics and history of the game world.

I’ve been really enjoying running the campaign, and also the two times I’ve run that same one-shot. Thanks to all the people who have played or are playing!

Running the campaign is significantly more challenging than the one-shot. There’s a lot of preparation involved, and the improvisation required is trickier because player actions are more tightly connected to the setting (and plot). The one-shot is almost a wilderness adventure, while currently the players in the campaign are in a rather large city, and are dealing with a variety of people there, each interaction potentially setting off chains of events that I need to track in my head. That’s a huge part of the fun for me, trying to make the world an intricate one that reacts realistically to actions the players take while also having the world roll along without regard to player action just as the “real world” pays little heed to much of what we do in it.

I think that this setting, and this plot, are both the most detailed I’ve ever run. I put plenty of time and effort into campaigns when I was younger, but I think a lot more of that was spent on rules issues. Now I’m more focused on the less technical aspects—that, and the tools available to me for creating the world are far more advanced (as is my ability to use them). Back then I was using computers for as much of it as I could, but still spent plenty of time with pencil and paper. Now my key tools are Vim, TiddlyWiki, and Inkscape (not to mention reStructuredText, my web server, my Subversion repository, and my laptop, all of which are critical), and they really make the whole process far smoother.

For example, I’ve made maps for this campaign. That isn’t new. What is new is that these maps are simply far better than they ever were in the past (largely because I can’t draw, but can get around that limitation now). Not only are they better, however, but their digital nature makes it really easy to alter them as needed, so incremental progress is a lot easier to do. In addition, dealing with scale is far easier, and with Inkscape I get access to vector rather than bitmap graphics, and that makes adapting content far less hassle.

The city the players are in is Anaq’rest, and my map for that is quite large in its source form: 20,000 pixels high and 20,000 pixels wide. The scale is one pixel to one meter. I can go from street-level detail to district-level detail in the same file, a luxury I’m very happy to have. In the 1990s I might have conceived of a 400-square-kilometer city map, but I very much doubt I would have done anything but gotten discouraged by my attempts to make it. Now I have one I’m happy with, that I can develop incrementally, and that also serves as a street-level map when I need it.

Both creating and having a map are extremely helpful creatively when dealing with a city setting, too. I’m certain that this applies to any kind of creative endeavor, not just roleplaying. It makes it feel like a lot of things are already “there”, waiting to be discovered rather than made up, and in addition the creation of the map brought with it ideas about the city’s history and nature that simply wouldn’t have occurred to me otherwise.

The current state of the map, looking at the whole thing (20km x 20km):

The players are currently based in the district of Dockside, and this is a zoomed-in (5.5km x 5.5km) view of Dockside:

All of its streets are on the map, although I haven’t filled in all their names yet. Only specific buildings are there so far, too, as marking out every single building on the map seemed like a bit much. But eventually it might get close to that.

When it’s a little more polished/detailed, I’ll release it under a Creative Commons license, as I suspect that plenty of games might have a use for a map like this (particularly with its source files, which I would release also).

Tags: creativity, games, personal, Q’Rith, roleplaying, writing

2010 Goals: First Quarter Review

Tadhg — Tue, 30 Mar 2010 19:12:33 +0000

Yes, clearly my progress (or lack thereof) needs quarterly reports. And here’s the first one for this year.

I laid out the full list at the start of the year. I’ve accomplished some of them:

Celebrate my birthday. This still seems like a strange goal to have—but putting it on here helped me get it done, and I had a great time and don’t get why I didn’t do this for years. I’ll do it again next year!
Participate in the CrossFit Sectionals. Done!
Ten dead-hang pullups. Done; currently my best is 11, and I’m now aiming for 20 before going back to kipping.

I’ve made some progress on these:

Revive sfmagic.org. “Some progress” here means I’ve tried to get the code running again and have run into incompatibilities between Pylons versions. So, slightly closer, but not a lot of movement.
Run a roleplaying campaign. I’ve started it, and two sessions in it’s going well.
I’m presumably closer to my other fitness-related goals of a 300-pound deadlift, a sub-23:00 5K, and “Murph” in under 50:00.
It’s hard to judge progress on an amorphous goal like “building a sense of community”, but I think there’s been some.

I’ve made no progress on these:

Write at least one draft of the fantasy novel. I feel fine about this, and haven’t really tried to work on it. I know that at some point the desire to do so will resurface, and the key to getting it done is focusing on it when that happens.
Finish The Annotated Fantasy Bedtime Hour. Still something I just need to get down to doing…

Tags: coding, community, CrossFit, exercise, games, goals, MTG, personal, roleplaying, web-development, writing

Giles Bowkett on Finding New Programming Jobs

Tadhg — Tue, 23 Mar 2010 23:52:45 +0000

It’s too long, it’s full of self-promotion, and really it’s an ad for a video he’s selling, but it’s entertaining and contains some good advice: “Programmers: What to do if You Get Fired”.

This might be the best line:

If you’re looking for a better job, writing an amazing resume is a good place to start. I don’t mean just a better resume; I mean a resume that makes people stop asking if they should hire you and start asking if they can afford you.

—Giles Bowkett. “Programmers: What to do if You Get Fired”. Giles Bowkett’s blog, 8 Mar 2010.

Annoyingly, I find myself tempted to buy that video after reading his post…

So far, his 2008 presentation at RubyFringe seems pretty entertaining too. Maybe you should watch it after you’ve updated your résumé.

Update: at the end of that presentation, he says “build something because you believe it should exist”, which I agree with 100%.

Tags: advertising, coding, work, writing

@: A Triumph of Design

Tadhg — Tue, 23 Mar 2010 04:50:26 +0000

The New York Museum of Modern Art has added the @ symbol to its architecture and design collection. Originating perhaps as a Latin abbreviation for “toward”, it showed up on one of the early Underwood typewriters (possibly the Underwood 1; it was definitely on the Underwood No. 5) and was used for “at the rate of”, which usage still survives.

But it’s really being recognized as a landmark of design because of its use as the separator between username and hostname—specifically, in email addresses, chosen by Ray Tomlinson in 1971.

It has plenty of other uses, and while we’re here I’ll note that I use it as an imformal extension to reStructuredText: I surround links that have titles with @ symbols and have a script run through the text to insert the actual reST necessary to support that (which, sadly, does require a custom directive).

Tags: design, language, reStructuredText, software, tech, writing

An Introduction to Roleplaying Games

Tadhg — Mon, 22 Mar 2010 07:56:51 +0000

Today I ran for the second time the roleplaying one-shot I did in December, with a completely different group of players. Last time the new:experienced ratio among the players was 1:4, while this time it was 3:1 (also, last time the female:male ratio among the players was 2:3, while this time it was 3:1).

Because of the number of new players, I prepared a little introduction to roleplaying to give before starting play, and I thought that it was worth sharing more widely.

(This clearly applies to “pen-and-paper” roleplaying games and not other kinds; my personal preference for naming this style is “sit around the table”, SATT.)

What is Roleplaying?

At its core, roleleplaying is a mixture of three things: acting, storytelling, and problem-solving. All of these aspects are wrapped up in a game, and the fundamental mechanic of this game is the communication between you, the players, and me, the gamemaster. I describe to you the world as your characters experience it, and you tell me what choices your characters make.

Broadly speaking, the world, and your characters, could be anything and anyone. Today, the genre of roleplaying game we’re playing is fantasy, in particular a gritty style of “swords and sorcery”. Your characters are all part of a seasoned ex-mercenary band trying to find a quicker route to riches, “adventurers” in the senses of both “a seeker of fortune in daring enterprises” and “a seeker after power and wealth by unscrupulous means”.

Returning to the three core elements, let’s start with acting. You literally act the part when you speak in-character. In addition, you seek to inhabit your character in the sense of trying to understand what they would do, how they would react to their circumstances. Today, concentrate on that, on trying to figure out what choices they would make.

By determining their choices, you are in effect telling their story: overall the narrative of tonight’s story is jointly woven by all of us.

In the course of that narrative, you will naturally encounter obstacles for your characters to overcome. This the is the problem-solving part of the experience. You will need to act collectively as both players and characters to succeed.

You will also need some luck. Luck resides in the gap between player choice and character action: whether or not your characters succeed in executing the actions you have chosen for them. Although I’m always the final arbiter of any outcome, the game just isn’t as much fun if I simply decide what happens at every juncture. Instead, the bulk of the rules of this game—a variant of the venerable Dungeons & Dragons—and the bulk of the stuff on your character sheets is concerned with defining the capabilities of your characters and judging the likelihood of their successes at various specific endeavors. Rather than spend much time going through all that now, I’m going to try to shield you from most of the rules matter and take care of as much of it as possible myself.

The largest area where these rules are applied is combat. You’re in a violent realm, in a violent occupation, and it’s a violent game. Combat is like a subgame, with some similarities to boardgaming but a lot more possibilities—rather than the rules supplying all your possible options, you decide what you want your character to do and we try to come up with the closest fit in the rules to judge its effectiveness.

Which is also what we do outside of combat.

The preceding “What is Roleplaying?” section of this post is licensed under the Creative Commons Attribution-Noncommercial-Share Alike License, cc by-nc-sa. Please attribute using my name (Tadhg O’Higgins) and a link to this post.

Tags: games, personal, roleplaying, writing

“Let’s Enhance”

Tadhg — Mon, 08 Mar 2010 00:29:16 +0000

A particularly inane trope:

In case the point isn’t crystal clear: you can’t do that. There are no image enhancement programs that let you know what the data missing at the point of capture is.

There appear to be plenty of people who think this kind of thing isn’t just possible but trivial (people who have “chosen to be smart at other things”, perhaps), at least judging by the amount of times it comes up on Clients From Hell.

I’m prepared to cut Star Trek and Blade Runner, and to a lesser extent Battlestar Galactica, some slack given that they’re science fiction, and we don’t actually know what the software capabilities or the capture format was. In Blade Runner, my interpretation of that scene is that what Deckard has his computer system analyze isn’t a simple photo, but rather some kind of hologram with a much larger amount of stored information than is apparent.

The other clips, however, deserve nothing but scorn and have no excuse. The fact that it’s doing the impossible is one thing, and then there’s also the fact that it’s a completely tired idea that exemplifies bad, lazy writing.

Put aside the first consideration for a moment and assume that this kind of technology is commonplace—you wouldn’t have characters reacting the way they do in these scenes. Either the person responsible for the analysis would simply do it themselves, or, nobody would be impressed at all by the fact that it’s possible. Instead, here you get a mixture, as if the technology exists but somehow the character is a total genius for thinking of using it.

Note that some forms of enhancement are possible; if you get a blurry shot of a license plate, it’s theoretically possible to use probabilistic analysis to get the letters or numbers, because you know in advance what the possible answers are. But that’s very different from what’s shown in those clips.

Also note: this post is not meant to imply that any other aspects of the shows referenced above are necessarily more realistic in any way.

Tags: humor, science-fiction, technology, television, video, writing

The Unfeasibly Tall GBBMCSMB

Tadhg — Mon, 15 Feb 2010 19:50:02 +0000

I’ve always had a soft spot for good genre parody, regardless of genre, and The Unfeasibly Tall Greek Billionaire’s Blackmailed Martyr-Complex Secretary Mistress Bride is pretty damn hilarious. You can read the first chapter in HTML, or the whole thing at Scribd.

Tags: genre, humor, parody, reading, writing

First Post With Vim

Tadhg — Mon, 15 Feb 2010 04:05:48 +0000

Over the last couple of weeks I’ve been hacking away on scripts to customize Vim, replicating the scripts I made for jEdit. I’m more or less done, and this blog post is being written in MacVim. This hopefully means that when I’m done with it I’ll be able to publish it from within Vim, the same as with jEdit.

Writing scripts for Vim has been rather different from writing them for jEdit. jEdit is an editor with a robust API; Vim is an editor that kind of gives the user access to the API all the time, via keyboard commands, and scripting for it often consists of simply passing keystrokes. As an example, this is the Jython code for getting the current selection in a jEdit macro:

text = init.textArea.getSelectedText()

This is the Python for getting the current visual selection in Vim:

self.vim.command('normal gv"wygv')
self.vim.command("let tvar = getreg(’t’)")
text = unicode(self.vim.eval("tvar"), "utf-8")

From a programming perspective, jEdit is clearly a lot nicer to deal with.

I have two primary reasons for making the switch:

Future proofing: I couldn’t switch to the various pre-release versions of jEdit 4.3 because I couldn’t get my Jython scripts to work with them, and that made me worry that there simply weren’t enough people scripting jEdit in Python to make it likely that the plugin allowing Jython macros would be supported. Given how useful my scripts are, that would have trapped me with jEdit 4.2, or some future version, if support for JythonInterpreter flagged. Vim, on the other hand, seems to have a lot of people scripting for it in Python, and I don’t see Python support simply disappearing anytime soon with a new release.
Power/speed: I’m someone who’s quite inclined towards keyboard shortcuts in all applications, and this means Vim should be a highly efficient environment.
Mentality: Related to the previous point, I think that being able to manipulate text more powerfully will reinforce the approach of scripting as many steps as possible, rather than doing them (no matter how efficiently) manually. Even over the last couple of weeks, I’ve noticed that I’m more inclined to write scripts than to put up with various manual steps in my daily workflow.

So far I’ve mainly worked to replicate my jEdit setup in Vim, with a few small improvements here and there; the largest one is probably the live word count, which means that I can glance at the status line to see the current word count instead of having to select the text to be counted and then invoke the word counter. I’ve also tweaked it so it only counts the relevant parts of the document—for example, in this blog post, it doesn’t count the title or the datestamp.

I don’t intend to abandon jEdit, and have a feeling that I’ll use it for various things here and there, but I’ve switched over the Vim for the majority of my writing and programming.

Tags: coding, Jython, python, software, tech, text editing, Vim, writing

Better Word Count in Vim

Tadhg — Mon, 18 Jan 2010 07:40:14 +0000

I’m currently trying out Vim (again), and have made more progress this time, mainly due to Seth’s help. The key things that have made it better:

:set hidden. Absolutely critical, this. Stops Vim from complaining when you try to switch buffers and your current buffer has unsaved changes.
bufexplorer. Makes switching buffers a lot easier.
A better Python syntax file. I didn’t like the defaults.
My own indentation and syntax files for reStructuredText.

Really, though, the key first one was :set hidden. Before that I felt that I had completely misunderstood Vim’s file management model.

Once I got the syntax highlighting to a reasonable state, I ported my word count macro over to Vim. This wasn’t too hard after the inevitable character encoding problems. For working within Vim scripts, I strongly suggest using the following:

ulines = [unicode(line, "utf-8") for line in vim.current.buffer]

(Assuming your Vim encoding is set to UTF-8, of course.)

The Vim version of my script isn’t as versatile yet as the jEdit version, because I don’t know how to make it work with only selected lines (something that’s easy in jEdit). Apart from that, though, it seems to work quite well; the next version of it might do “live” word count in the status bar.

I’m currently writing this in Vim, or kind of: the actual writing is in Vim, but the creation of the file and the template, the automated expansion of various reStructuredText entities, output to reStructuredText, and the publication, are in jEdit as I haven’t ported those over yet.

The script:

function! WordCount()
python << EOF
import re
import vim

class WordCounter(object):
    """
    Vim script for better word count.
    """

    LINE_SEPARATORS = (
        "\r",
        "\n"
    )

    WORD_SEPARATORS = (
        " ",        # space
        "\t",       # tab
        "/",        # slash
        "&",        # ampersand
        ’"’,        # double quotation mark, straight
        u"\u201C",  # double quotation mark, left
        u"\u201D",  # double quotation mark, right
        u"\u2018",  # single quotation mark, left
        u"\u2013",  # en dash
        u"\u2014",  # em dash
        ">",        # greater than symbol
        "<",        # less than symbol
        "+",        # plus
        "=",        # equals
    )

    REPEATER_SEPARATORS = (
    #These are only separators if they’re present consecutively, e.g. -- or ..
        "-",
        "."
    )

    IGNORE = (
    #Not separators per se, but should not be treated as word content
        "’",        # single quotation mark, straight
        u"\u2019",  # single quotation mark, right
        "(",        # left parenthesis
        ")",        # right parenthesis
        "[",        # left bracket
        "]",        # right bracket
        "{",        # left curly bracket
        "}",        # right curly bracket
        "|",        # bar
        "-",        # hyphen
        "#",        # hash mark
        ".",        # period
        "_",        # underscore
        "`",        # backtick
        "\\",        # backslash
    )

    def word_count(self):

        ulines = [unicode(line, "utf-8") for line in vim.current.buffer]
        text = u"\n".join(ulines)

        chars = len(text) #Pretty sure I want the actual char count, not the adjusted char count.

        text = self.remove_directives(text)
        text = self.adjust_for_rest(text)
        words, lines = self.count_words(text)

        print "chars: %s, words: %s, lines: %s" % (chars, words, lines)

    def remove_directives(self, text):
        textlines = text.split("\n")
        newlines = []
        comment = re.compile(r"[ ]*\.\. [a-zA-Z0-9_\|]")
        argument = re.compile(r"    :[^\:]*:")
        for line in textlines:
            if not comment.match(line) and not argument.match(line):
                newlines.append(line)
        return "\n".join(newlines)

    def adjust_for_rest(self, text):
        """
            Go through each of the special cases for reST.
        """
        text = self.rest_adjust_pipe_space(text)

        return text

    def rest_adjust_pipe_space(self, text):
        """
            Special-case "|\ " to make sure e.g. "|Hypnotic Specter|\ s"
            doesn’t get counted as three words.

            |Incinerate|\ s |Hypnotic Specter|\ —|Hypnotic Specter|\ s
            The above line should be counted as five words.
        """
        spacere = re.compile(r"\|\\ ([^ ]{1})")
        finds = spacere.findall(text)
        text = spacere.sub("|\g<1>", text)
        return text

    def count_words(self, text):
        words, lines = 0, 1
        #go through the text character by character:
        word, previous_character = 0, None
        for character in text:
            if character in (self.LINE_SEPARATORS + self.WORD_SEPARATORS) or (character in self.REPEATER_SEPARATORS and previous_character in self.REPEATER_SEPARATORS):
                #it’s a separator
                word = 0
                if character in (self.LINE_SEPARATORS):
                    lines = lines + 1
            elif character in (self.IGNORE):
                pass
            else:
                #it’s part of a word.
                if not word:
                    words = words + 1
                    word = 1
            previous_character = character

        return (words, lines)

WordCounter().word_count()
EOF
endfunction

if !exists(":WW")
  command! WW  :call WordCount()
endif

Tags: coding, Jython, python, software, tech, text editing, Vim, writing

tadhg.com » writing

Perfectionism is Hard

Related Posts

Three Routines

Related Posts

How to Cheat in the Leaving Certificate on YouTube

Related Posts

Original Draft of The Empire Strikes Back

Related Posts

sabbatical.close()

Related Posts

Improving a Python Word Counting Function

Related Posts

“Wandering Mind”

Related Posts

Refactoring, Geeky Enjoyment, and Readability

Related Posts

Anaq’rest

Related Posts

2010 Goals: First Quarter Review

Related Posts

Giles Bowkett on Finding New Programming Jobs

Related Posts

@: A Triumph of Design

Related Posts

An Introduction to Roleplaying Games

What is Roleplaying?

Related Posts

“Let’s Enhance”

Related Posts

The Unfeasibly Tall GBBMCSMB

Related Posts

First Post With Vim

Related Posts

Better Word Count in Vim

Related Posts