I've read several times lately on the web and in books about how coding
requires left brain and when interrupted it knocks you into right brain
mode. It then takes some time (1-2 hours) to get into proper left brain mode
again. I've felt that way for a long time (not sure about 2 hours but after
a minor interruption (even if it's only for 1 minute, or a phone ringing) it
knocks me straight out of concentration and it takes me at least 5 minutes
before I can start to code again (much longer to reach full speed). Plus of
course all these interruptions when halfway through writing a line of code
or SQL statement all increase the chances of bugs particularly if when I
come back the line or function looks at first glance to be finished when it
isn't. I may even have totally lost my position in the code (or even forgot
what program I was editing) as a result of being called into a meeting
suddenly on my way back to the office from some other department and the
meeting in question involved an RDP session into my PC to view something on
there (which happens to rearrange all the window sizes, which monitor they
appear on, etc).

Anyhow, just wondered what the level of interruptions is like elsewhere,
really. Generally, the longest block I have in a typical day without an
interruption is about 40 minutes. The majority of these come from either the
IT manager or one of the other developers (I am one of 3 in total at my
company). Requests from the IT manager are mostly minor alterations
requested for programs (change of some text somewhere on the user interface,
change of wording in an automated e-mail, etc) and from one of the other
developers requests for help (sometimes database related but mostly obvious
problems that I'm sure he could fix himself if he spent another 2 minutes on
it). The other developer does not require assistance anywhere near as much.

I've asked them both to e-mail me these things instead of just standing next
to me and talking but it never seems to happen (and in the IT managers case
he's usually too busy running around the different departments to get to a
PC and send an email anyway). E-mail doesn't really bother me at all as
there's several different points throughout the day when I'm between tasks
and can read/respond without losing track of the particular feature /
function I'm working on.

So, what's typical elsewhere, and any advice on dealing with the problem?
I've also posted a typical work day in a separate post here.

Anon wrote:
Maybe you have some aspergers (like me, or just plain monotropic

http://brain.hastypastry.net/forums/...p/t-61501.html

Anon wrote:

It is very sad that people who would never indulge in cartomancy or
astromancy (astrology) consider the pseudoscience of "bicameral mind"
theories to be more than a metaphor.

The problem with interruptions to Flow is that programming requires filling
your short-term memory up with a structure shaped like your progrom's object
model, executing in memory. People who can't do this ("where do all those
pointers point to again?") can't program.

Interruptions destroy this short-term memory. Verbal interruptions replace
it with your verbal abilities. Nothing to do with the dichotomy between
logic and intuition.

The solution I have found works best is Instant Messaging, and chat.
Sometimes I would rather IM someone 2 workbenches over from me than yell to
them.

Chat provides an _optional_ interruption. I send the message, go back to
work, and wait for the recipient to chat back. This is better than e-mail
(which we pull only hourly), because it _must_ come from within a team.

When you write lots of unit tests, and run them after every few edits, each
test run reenforces your mental model of the code's state. That's why you
should consciously predict the result of each run - either passing, or
failing because the test is waiting for you to add a new code ability.
Shrinking the size of each edit between test runs makes interruptions more
manageable. When you return from the interruptions, the tests make
rebuilding your mental model easier.

This technique complements the help desk tickets I specified in the other
post.

--
Phlip
http://www.greencheese.org/ZeekLand <-- NOT a blog!!!

Phlip writes:

It has a *little* more scientific basis than that, but that is neither
here nor there.

Regardless of the interruption.

I can't speak to the work modes of others, but it's not uncommon for
me to be--figuratively speaking--several "sub-routine calls" into a
process that requires successfully "popping each frame off the stack"
on the way back to the main process.

Interruptions are deadly when that's happening--usually results in
"stack corruption" of some sort.

An image I've used to communicate this to non-programmer managers is
that of those jugglers you used to see on Ed Sullivan. The ones with
all the plates spinning on vertical sticks. They'd dash around like
crazy keeping the spins going.

Programming can be like that. Lots of stuff going on that you need
to keep on top of. Get interrupted and plates begin to crash onto
the floor.

--
|_ CJSonnack <Chris@Sonnack.com> _____________| How's my programming? |
|_ http://www.Sonnack.com/ ___________________| Call: 1-800-DEV-NULL |
|_____________________________________________|___ ____________________|

Chris Sonnack <Chris@Sonnack.com> writes:

Same here, and it causes no less than two different problems. When
interrupted, first you start losing your mental flow on the computer
problem as you're interrupted. Second, while that happens you're
nevertheless partially still "in it".

That means you probably don't understand -- or you just stare into a
distance and plain ignore -- what the other guy was saying to you.
Then you respond "Mmm-ummm, yeah, hmmm-hm" to get rid of him and end
up both not knowing what was he actually trying to tell you AND losing
your focus on the programming issue.

:-(


***

Except for interrupts which you can't always avoid, I have some habits
to serialize the state of my mind if I have the time to do that.

Those habits are useful if I know I have to leave and can't finish up
something in time. Working on something that's "almost finished" would
be pretty frustrating otherwise. Also, frequent requests to "come on!"
eventually serve as those deadly non-maskable interrupts, so you want
to shut down your mind gracefully before that happens.

I think what the habits are is not important -- they're just random
methods of writing down a note in your mind. In other words, they
activate certain, carefully learned behaviour in your brain. Also,
they're never perfect at restoring the state, but I find them
undoubtedly useful often enough to keep using them.

One of the best habits I have is deliberately broken source code. If
the source doesn't compile/evaluate (and possibly has some key ideas
or future sketches written in it in English, pseudocode, or the
original language) the situation looks fairly promising the following
day.

I know the brokenness will bother me a lot which practically enforces
me to fix the code somehow as soon as possible to make it
compilable/runnable again. Now, when I start working on the exact same
spot where I left, my mind starts remembering all the other details as
well and I get a gradual dejavu. There's something learnable in it,
because I didn't become really good at it until after working a few
years in an environment where such an escape was practically a
requirement.

These days, in the best case I completely remember what I was
essentially working on in a matter of 5-15 seconds. After an
involuntary interruption that left you no time to build your mental
mark, it could take hours in the worst case.


br,
S

--
firstname.lastname@iki.fi -- Today is the car of the cdr of your life.

Replies inline.

"Phlip" <phlipcpp@yahoo.com> wrote in message
news:<1ko_e.426$056.72@newssvr19.news.prodigy.com> ...

Yeah I don't really know much about how the human brain does and which part
does what etc but I agree entirely with that last paragraph. I just
sometimes have trouble explaning it and the left/right brain thing is
something I've seen several times lately.

I don't mind instant messaging that much - I can always minimize someone to
the system tray (using a utility called powermenu) if they keep distracting
and I don't want to lose their messages. I prefer email though as sometimes
IMs get lost and forgotten about when restarting the computer etc (since the
IM client installed on our machines at work does not support logging etc).
E-mail therefore provides a more permanent record and can be flagged with
reminders and organized into appropriate folders etc.

"Chris Sonnack" <Chris@Sonnack.com> wrote in message
news:tkhlj150q2pua2vb6i5sarj9tqljuf12uo@4ax.com...
Yes I agree with that. Sometimes a change might require a minor change to be
made in 5 different parts of a program. The effects of some of the changes
going live but not others could be deadly and if you've spent some time
figuring out what needs changing, and you've made 3 of the changes, then get
interrupted, you may forget about the other 2.

Also while working in a function you might notice something wrong with
another function, and then something wrong in another, and that can lead to
a stack of problems. I try to make a quick note to fix it later and finish
what I'm doing in the current one to work around that though.

In an ideal world the changes would be planned out and documented before
being made but in reality we're always being rushed, usually by the managing
director such as when he requests a new feature and wants it ready within 5
minutes to show in a presentation to another company. Another time he asked
our web developer for a pretty major reworking of our website (which is the
source of most of our orders) and demanded it was live within 30 minutes.
The web guy protested and was basically told "Forget about all this
documentation bullshit, just do a quick job, we'll take the bugs out later"
(we're told that quite often, by the way). At one point he stood behind the
developer counting down the remaining time he had left.

When developing new software I might have thought of a way to solve the
problem but an interruption before I've finished getting it all down (into
either code or a quick english explanation) may cause me to forget the
solution and have to work on it again.

Out of interest how much detail do you go into in your design work? For new
software that is likely to take more than a couple of days I try to at least
get down a UML diagram planning out what classes will be used and how they
will link together along with the more important public methods. I don't
include private methods at this stage however, but I include XML comments
for nearly every method in code. When maintaining older software there is
never any documentation or comments in the programs so I try to map out
which functions call which other functions, and what they do, plus decipher
the various variable names. These older programs are all written in classic
VB (so no OO), the functions are named things like cewrtwrt_Click(),
dojob(), dojob7(), etc and the variables for most of these are global and go
from Z1 to Z30.

"Simo Melenius" <firstname.lastname@iki.fi-spam> wrote in message
news:8764slt0ss.fsf@sme.intra.citec.fi...
Yes, I can easily switch my mind to focussing on what the person is saying,
but there's always a reluctance to do that because as soon as I pay any kind
of attention whatsoever I'm out of "it" and it takes me a long time to get
back in "it".

Interesting idea that I've never tried. What I do mostly is set a bookmark
on the line I'm on (all the development IDEs I use support this), add a
quick "// TODO: Finish!" and if necessary enter a few lines of text into a
quick notepad window. It helps anyway. I probably don't do this enough as
sometimes something seems like a 2 minute disruption and I think I can
probably remember what I was doing for another 10 minutes or so, but while
dealing with the 2 minute disruption a longer disruption comes up. I've
often ended up with a stack of tasks each new one pushed to the top of the
stack more important than the one below it that have had nothing to do with
any main project.

Or in some cases, you may not remember at all until testing. Even worse, it
may be that you weren't even in the middle of a piece of code, but had
suddenly had the thought "Hmm, this design isn't going to work after all.
Part of the architecture will need to be changed to work xxxx way, because
of yyyy.". By the time you're back, you're carrying on with the old design
that later needs to be scrapped as it doesn't work because of yyyy. I don't
*think* this has ever happened to me, but I see it as a risk.

Anon wrote:

Then feel free to go with the _spiritual_ ideal that the mind has an
intellectual and an emotional component, both valid and useful. That's the
meaning which people endow the brain hemispheres with.

Modern IM is logged. ;-)

--
Phlip
http://www.greencheese.org/ZeekLand <-- NOT a blog!!!

Phlip wrote
(in article <J7I_e.441$Vk.245@newssvr24.news.prodigy.net>):

Not if you do it point to point using your own encrypted
protocol. Oh, you mean some sheeple still use those public
communication systems? Bizarre to give up that much privacy for
the ability to look up complete strangers in an address book.


--
Randy Howard (2reply remove FOOBAR)

Anon wrote:

I wrote a song about it. Right out of me head:

http://www.c2.com/cgi/wiki?TooMuchEmail

--
Phlip
http://www.greencheese.org/ZeekLand <-- NOT a blog!!!

Phlip wrote: