(BUTTON) Toggle navigation [1]SteveStreeting.com
* [2]About
* [3]Blog
* [4]Feed
Work 2.0 - the interruptible programmer
4 Sep, 2010 · by Steve · Read in about 10 min · (1981 Words)
[5]coding [6]Development [7]GTD [8]Health [9]Productivity
[10]programming
I’m 37, and I’ve been a (professional) developer for 16 years. You
would have thought that in that time, I’d have figured out an effective
work style which delivered the desired outcomes (code cut, products
shipped etc) without causing detrimental knock-on effects - but, sadly,
you’d be wrong. I think the style in which I practiced my craft for the
first 15 years of my career was much the same as every other
enthusiastic developer: you put a ton of hours in. 12-16+ hour days,
evening and weekend coding marathons, pizza in the keyboard, crunch
times, 3am debugging sessions where you just can’t go to bed because
you can feel the source of that bug just beyond your fingertips,
dammit, desperate last-minute sprints to deadlines where you manage to
slot that last piece in, Jack Bauer-like, just before the world goes to
hell. If you’re in the demographic I’m talking about, you’re nodding
sagely, and probably grinning a little too, reminiscing on past trials
and glories. This sort of crazy dedication is respected in our circles,
and is pretty much expected of any developer who has claimed to earn
their stripes.
But, it turns out this kind of thing is not good for your health - who
knew? Those of you who know me or keep up with my blog know that I’ve
been dragged kicking and screaming away from my old ways, because of
back issues that I initially ignored, then tried to cope with using
token accommodations, and finally succumbed to in a big way. Being
self-employed, this was a major problem. Crawling out of the pit I dug
for myself took a long time and a lot of frustration - I read quite a
few productivity books on the subject to try to find answers on how to
keep working, and in the end found that the answers you mould for
yourself tend to be the best ones. I’d like to share one of the things
I learned along the way.
But I’m ‘In The Zone’!!
So, I want to talk about the biggest problem I encountered:
concentration periods. I can’t sit at a desk for longer than about an
hour at a time now; if I don’t get up and walk around, do some gentle
stretching etc, at least this often, I’ll pay for it badly once I do
move, and probably over the next few days too. I also can’t
realistically work more than a standard 8 hour day without pain any
more. The problem with this was that, as a programmer, the style which
I developed over 15+ years involved getting gradually ‘Into The Zone’
and coding for very long periods at a time, uninterrupted. This is a
common theme among coders, who like to shut themselves away for hours
at a time, wear headphones to avoid distractions, have ‘quiet times’
and so on - and it’s also why we tend to react really badly when
interrupted. Programming requires concentration, and concentration
seems to run on a valve system - it takes time to warm up, and once
it’s going, you don’t want to turn it off because starting it up again
is a major hassle.
I thought there was no way around this, and had begun to resign myself
to just being less productive because of it. However, over the last 6
months in particular, I’ve discovered that, far from being an
intractable problem, this ‘slow warm up, long uninterrupted focus time’
approach is to a large degree a learned behaviour, and it’s possible to
re-train yourself to cope with things differently. It’s a little like
when people learn to adopt [11]polyphasic sleep patterns - it’s not
that you can’t do it, it’s just that when you’ve become accustomed to
doing things a certain way, changing that is initially very, very hard.
But it’s not impossible, given the right amount of motivation and time
to adjust.
So, my goal was to acclimatise myself to many shorter work chunks
during the day instead of a few very large ones, while still
maintaining productivity. The key to this was to learn how to get back
‘In The Zone’ in the shortest time possible - much like the way
polyphasic sleepers train themselves to achieve REM sleep more quickly.
I’m mostly there now, or at least way better at it than I was, so, what
techniques did I use to make this transition?
1. Embrace interruptions
This is less of a technique and more of a deliberate psychological
adjustment which cuts across all the practical approaches I’ll
cover next. Instead of being the typical coder who
avoids interruptions at all costs, you need to accept them, and
learn to manage them better. It’s hard - you have to try to set
aside years of resisting interruptions and initially, until you
adjust, you’ll feel like you can’t get enough done. Many people
will probably want to give up, unless there’s something specific
motivating them to push through it - for me, daily pain was a great
motivator. My main message here is that the transition is just a
phase, and that it is possible to be an interruptable programmer
who still gets things done. But you have to learn not to fight
against it, hence why this is the first point.
2. Maintain context outside of your head at all times
Much of the problem with interruptions is that of losing context.
When you’re in that Zone, you’re juggling a whole bunch of context
in your head, adjusting it on the fly, and maintaining and tweaking
connections between issues constantly. Interruptions make you drop
all that, and it takes time to pick it all up again. My answer to
this was to externalise as much as possible, on as many levels as
possible:
1. **Maintain a running commentary on your current task
I am my very own chronicler. ** I write notes on what I’m doing all
the time, whether it’s adding a comment line to a ticket,
committing frequently and writing detailed commit notes (you do use
a DVCS to make light commits more practical, right? ;)) scribbling
a drawing on (ordered) pieces of paper. This really isn’t that
onerous, and in fact externalising your thoughts can often help you
clarify them. Basically the guide is that roughly every 30 minutes,
I should have generated some new piece of context which is stored
somewhere other than my head. If I haven’t, then that’s context I’d
have more trouble re-building mentally if I’m interrupted. It
doesn’t take much time to do, and it has other benefits too such as
recording your thought & decision process.
2. **Ruthlessly ignore tangental issues
You might have noticed that in the last bullet, I used the words
‘current task’, singular. Not ‘tasks’. There is no such thing as
having more than one ‘current task’ - there is only the one task
you’re actually working on, and distractions.
We probably all use bug trackers / ticket systems to track bugs and
feature requests, but when you’re working on a ticket, it’s very
common to spot a new bug, or identify an opportunity for
improvement, or think of a cool new feature. How many of us go
ahead and deal with that right away, because it’s in the area we’re
already in, or it’s ‘trivial’, or it’s a cool idea that you want to
try right now? I know I did - but I don’t any more; any tangental
issues not related to what I’m currently doing get dumped into the
ticket system and immediately forgotten until I’m done with the
current task, regardless of their size, relevance or priority. It
sounds simple and obvious, and this might even be official
procedure in your organisation, but I challenge most coders to say
that they actually do this all the time. The benefit is that even
the tiniest of distractions add an extra level of context that you
have to maintain, which is then harder to pick up again after an
interruption.
For this to work, you need a ticket system which is fast,
lightweight, and doesn’t require you to be anal about how much
detail you put in initially. You need to be in & out of there in 30
seconds so you can offload that thought without getting distracted
- you can flesh it out later. **
3. Always know what you’re doing next
This is one from GTD (‘Next actions’), but it’s a good one. When
you come back from a break or interruption, you should spend no
time at all figuring out what you need to be doing next. Your
ticket system will help you here, and so will the running
commentary that hopefully you’ve been keeping on your active task.
If you’ve been forced to switch gears or projects, so long as
you’ve maintained this external context universally, you should
have no issue knowing what the next actions on each item are. The
important thing is to have one next action on each project. If you
have several, you’ll have to spend time choosing between them, and
that’s wasted time (see the next section on prioritisation). At any
one time, you should not only have just one current task, but one
unambiguous next action on that task. Half the problem of working
effectively is knowing what you’re doing next.
Prioritise Negatively
I mentioned next actions in the previous section, but how do you decide
what comes next? A lot of time can be frittered away agonising over
priorities, and I used to struggle with it; I would plan on the
assumption that I wanted to do everything on the list, and I just
needed to figure out which I needed to do first. I discovered that I
could cut the amount of time I spent on planning, and also get better,
less ambiguous priorities by inverting the decision making process - to
assume a baseline that I wouldn’t do any of the tasks, and assessing
the negative outcomes of not doing each one. So instead of ‘which of
feature A or B is more important to have?’, it became ‘Let’s assume we
ship without feature A and B. What are the issues caused by omitting
them in each case?’. It might appear to be a subtle difference, but
having to justify inclusion entirely, rather than trying to establish a
relative ordering assuming they all get done eventually, tends to tease
out more frank evaluations in my experience.
Recognise the benefits of breaks
Much of the above is about limiting the negative aspects of taking
breaks, but the fact is, that they have many work-related benefits too.
I’m willing to bet that all coders have stayed late at work, or late
into the night, trying to fix a problem, only to find that they fix it
within 15 minutes the next day, or think of the answer in some unlikely
place like the shower. The reason for this is very simple - extended
periods of concentration seem productive, and can be on operational /
sequential thinking, but for anything else such as creative thinking or
problem solving, it’s very often exactly the opposite. Not only do
tired minds think less clearly, but often the answer to a problem lies
not in more extensive thinking down the current path which you’ve been
exploring in vain for the last few hours, but in looking at the problem
from a completely different perspective. Long periods of concentration
tend to ‘lock in’ current trains of thought, making inspiration and
strokes of genius all too rare. Creativity always happens when you’re
not trying, and it’s an often under-appreciated but vital element of
the programming toolbox. Interrupting that train of thought can
actually be a very good thing indeed.
There’s more I could talk about, but that’s quite enough for now I
think. I hope someone finds this interesting or useful 😀
* [12]←Previous
* [13]Next →
[14]back to top
Make the things you want to exist.
© 2018 Steve Streeting.
References
1.
https://www.stevestreeting.com/
2.
https://www.stevestreeting.com/about
3.
https://www.stevestreeting.com/
4.
https://www.stevestreeting.com/index.xml
5.
https://www.stevestreeting.com/tags/coding
6.
https://www.stevestreeting.com/tags/development
7.
https://www.stevestreeting.com/tags/gtd
8.
https://www.stevestreeting.com/tags/health
9.
https://www.stevestreeting.com/tags/productivity
10.
https://www.stevestreeting.com/tags/programming
11.
http://www.everything2.com/index.pl?node_id=892542
12.
https://www.stevestreeting.com/2010/08/08/cocoa-tip-using-custom-table-outline-cells-designed-in-ib/
13.
https://www.stevestreeting.com/2010/10/26/introducing-sourcetree/
14.
https://www.stevestreeting.com/2010/09/04/work-2-0/
