# A day's journey

## Riding until dawn

Programmers are always trying to find new ways to be productive. Tweaks to text editors, compilation tweaks, scripts and automation; the list goes on for how programmers want to maximize their productive time coding. We also spend time tweaking the rest of our lives with the belief that we should always be doing something related to coding. Any moment we're not coding is a moment where our projects get behind. And getting behind with our coding can lead to other problems: missed deadlines, other companies getting their program to market before us, or other instances where we miss an opportunity. We're constantly worrying that we're not doing enough to succeed.

We've heard the stories of developers waking up at their computers to the strange sound of beeping because they fell asleep at the keyboard and the keyboard auto repeat can't handle any more input with their face resting on the keys. Isn't that how developers should work?

There's a tendency to think that because we work with machines that are tireless and ready for more work that we need to behave in the same way; we need to constantly utilize these resources. We try become like the machine; tireless and always ready for more work. 

There's a problem with always being "on". When we feel like we always have to be "on" we never let ourselves feel like we can be "off" again. We don't allow ourselves the time to be off. This creates a pattern where we deny ourselves the moments to sit and reflect on what we're doing.  We force ourselves to keep moving; keep programming no matter the personal cost. Our brains don't get the ability to rest, relax, and recharge. Our minds are too busy and exhausted to process what we've learned and sweep that knowledge into long-term storage. When we get exhausted we start to worry that we're not doing enough. This doesn't motivate us; instead we create a vicious feedback loop of fear and panic. We spend our day worrying that we're not doing enough while our minds cry out "enough!" from exhaustion. This feedback loop of fear and exhaustion can spiral us into a vortex of burnout, depression, and a desire to leave programming for good.

There's a delicate balance that we need to strike between our desires of being on all the time and our needs for relaxation and reflection. Our desires for invincible and indefatigable development need to be tempered with the reality that our bodies and minds have finite resources per day and must be allocated appropriately. Think of this as power-management for a complex machine that the manufacturer (currently) won't let you swap the battery out for a new one. Being aware what processes are running, how much energy is being used, and how much energy is left would be vital to ensuring you could still be running that machine later on in the day. That's the level of awareness that we'll need to have about ourselves.

How do we balance these feelings of wanting to be on all the time while allowing ourselves to relax and reflect on what we're doing? How do we pay attention to the needs of this programming machine?

## Lights out

First we need to acknowledge that we can't be on all the time. You may know this intuitively and think "yes, of course" but knowing is not the same as doing. We need to have a periods where we are not programming and not thinking about programming. We need to have moments where we can turn off the programmer part of our being. These periods of not-programming are vital to our well-being and give us chances to explore the wider world and let our minds rest in-between programming sessions.

This can be tricky if we feel like we're falling behind in our learning. When are we supposed to learn all of the new things happening daily? When are we supposed to catch up on all of that technical debt you've been accruing over the years? When will we have time to learn the ins-and-outs of technologies that aren't part of our day-to-day work but are still interesting to us?

These feelings that we have (that there's more to do and that we need to spend every waking moment doing it lest we fall behind) isn't helped by programmers who look super productive. These are the programmers that think of a clever idea in the morning and have a working prototype in the afternoon (while still handling normal work routine). When we compare ourselves against these programmers we wonder if they ever take time away from the computer.

We can acknowledge that we have feelings of wanting to push ourselves to keep learning and doing. We can see ourselves when we think "just one more line of code before bed" or convince ourselves "I  can read a few more articles or pages or [insert favorite way to consume more information here]". We can pause and see where these feelings and thoughts come from and understand why we're still pushing ourselves beyond exhaustion.

These feelings usually stem from a sense of inadequacy. We feel like we're not measuring up to the ideals we have; whether these ideals are ones we've created or ones that are externally driven. These ideals come from analyzing other programmers (colleagues or folks we admire), and measuring our progress against their work. They also come from our own mythical idea of what the perfect programmer is.

What we need to realize is that those ideas of what makes good and perfect programmers are fantasies. They're a composite of what we think a good and perfect programmer should be. They don't exist in the real world. True, we may see programmers out there that seem to wake up with a keyboard attached to their hands, spend the entire day coding, and go to sleep with dreams of more code formulating in their heads. But we need to realize that we're only seeing one side of their lives. We're not seeing the whole picture of who they are. We need to focus on our own bodies and minds and realize when they're tired and need rest. We can't make ourselves into other people, we need to work with who and what we are. 

Our bodies require down-time in order to be most effective. We need moments where we can step away from the keyboard and allow ourselves to wind down and relax. Our minds are not designed for constant work, especially at the levels that computer programming requires. The sooner we realize we should step back and take breaks throughout the day to recharge ourselves the happier (and more productive) we will be.

## Taking a break

Taking a break is more than just flipping over to another application on our computer. My tendency while taking a break is to start checking my email or open up one of my various chat programs to catch up on what happened since I last opened it (usually since the last time I took a break). But this really isn't taking a break as it is trying to multi-task at my desk. Real breaks involve getting up from the computer. It doesn't have to be a large break; taking a break can be as simple as standing up and walking away from your work-space into another room or area. But you you need to stand up from your computer to get a "context switch", where your mind can feel like it isn't in the same place as it was earlier. Context Switching lets your mind completely switch out and flush out the context of the area you're in. It allows your mind to focus on new context and new input.

This can be tricky in an office where the underlying expectation is that one must be at their work space in order to be productive. And there are only so many "bio breaks" (breaks that are related to matters of human biology, also known as using the restroom) someone can take in such situations. How can you give yourself the context switch your mind needs in such situations?

You might be able to achieve the same sort of context-switch by looking away from the computer display for a few moments. It's a good idea to look away from the screen every now-and-again to give your eyes a rest. Giving your mind a rest while you give your eyes a rest can give you the incentive to do both.

Changing your sitting / standing arrangement can also be a good context switch where you give yourself a context-switch around your physical workspace. It can be as simple as just standing up and stretching from time to time, or as complex as raising or lowering your standing desk. Telling yourself that there are two contexts around your desk: sitting and standing at the desk, may be enough to give yourself the context switch and rest that your mind needs.

If your workplace has a culture that allows you to step away from your desk and walk around then that would be a great context switch. Adding a physical component (as much as you are able) to your context switch can help your mind to relax and recharge.

You'll have to experiment with a few of these and see what works. At the bare minimum you'll want your mind to feel as though it doesn't have to be on all the time. You want your mind to have cool-down periods between coding sessions so it can flush the remnants of that session from your mental "cache" and into longer-term storage. Then when you get back to your coding session you'll be more likely to remember what was going on.

You may also find that when you step away from the computer that you forget a lot of what you were previously doing. That's OK too. What I would recommend is keeping a journal or log of what you were thinking in as much detail as you need. Either write them on a physical piece of paper or use a text file to keep these notes so you'll have enough clues to allow you to pick up where you left off.

## Productive thinking

Next we need to realize that productivity is not a constant. There are days where we will find ourselves generating remarkable levels of code and code quality and days where we'll be lucky if we can string together a coherent string of words to add to a commit message. We have varying levels of energy and mental focus available to us per day. It's up to us to be mindful of these levels and understand what our productivity might look like for the day. 

Understanding these swings of productivity can allow us to better gauge whether or not the day will allow us to generate the code that needs to be generated, but there's a level below that I think is important.

We put a lot of emphasis in our day on completion and hitting deadlines. This emphasis can lead to us creating strong attachments to completion and deadlines. Sometimes this is warranted because of external factors (the "critical-path" of the project require us to get this done by a certain date and time). But many of our deadlines are internal deadlines that we've set for ourselves. We set a goal that we will be this productive by the end of the day. The unstated condition of this internal productivity deadline is that we'll feel guilty and ashamed if we miss the goal. We'll fee like we're not measuring up to our expectations and wonder if we're worthy of the task at hand. We'll feel like our day has been wasted and wonder if we're capable of doing anything at all.

It's better for us to remove deadlines wherever possible. We won't be able to get rid of the external ones where folks are waiting on our contributions (though we may want to renegotiate those if they're not hard deadlines) but we can let go of the desires to hit arbitrary productivity and meet arbitrary deadlines. 

Arbitrary goals may work for some tasks. Some game contests only run for a week which makes teams focus on the critical pieces of the game in order to release it in the allotted time. But if you continually feel guilty and unworthy because you can't seem to meet the goals you set for yourself then you'll want to reconsider using them at all.

One thing that I have found is to narrow the focus to the present moment using containers.

## Containers

We should replace soft deadlines (deadlines that aren't externally imposed on us) with a commitment to work on a particular project for a given length of time. One trick I've found useful is the idea of a timed focus container. When I do a timed focus container I start by choosing what will be focused on during the container. Once the task is chosen I set a timer at my work-space and then focus on that task with my full attention for the remainder of the time on the timer. I've had the best luck with using 10 minutes but a session as small as 5 minutes or as large as 25 minutes can be useful. The work selected at the beginning of the container is the only thing I work on and I do my best to make sure there are no interruptions (whether internal or external) until the container is complete. When the work is done I wrap up wherever I landed and then take a quick break (about 5 minutes) before starting the next container. The next container can continue with the same task, or I can select another task. But the idea is simple: I only focus on the thing in front of me for the allotted time. When my mind tries to wander or I get the temptation to "just check this one thing" I pause for a moment and see if it is indeed important. More often than not it isn't as important and I can make a note to check in on that after the container.

#### FIXME

When we start the container we see where the session takes us. There is no judgment of the quality of the work in the container; just the expectation that we will work for the duration of the container. There's also no expectation about what we will have accomplished when the container is finished. If we complete the task before the container ends then that's awesome! We can then figure out what out next task will be.  If the container ends and we're still in the middle of debugging a problem perhaps we write down where we left off and what steps we took in order to get there and then work on something else. Or we get up for a bit and come back to the session in progress.

The underlying concept for the container is just to agree to work in the container without judgment for the work done and for the progress made. When the work is done in the container we take a step back and reflect on what we did and where we need to go. We give ourselves permission to not have to worry about it in the moment, but also allow ourselves the freedom to look back in short increments and see how we're doing. We allow ourselves to just work in the moment without fear of judgment, reprisal, or self-recrimination. We give ourselves the gift of uninterrupted work (or at least as much as we can possibly give). And we give it our full attention by turning off notifications, closing other programs, and focusing on the work in front of us.

I'd like to invite to to take on this practice of doing focused containers. I think they're an excellent way to give ourselves permission to just focus on one thing at a time without 

## Distractions

Life is often full of distractions that are beyond our control. Someone walks up to our work-space and needs our attention at that moment. An email thread that we thought was settled becomes a heated discussion and needs our attention. Something happens at home and now our minds are split between work and home. Whatever the cause may be there are times when our attention isn't where we feel it should be and we feel pulled in every direction at once.

This is where the containers can be most helpful. If someone interrupts the container we can determine if it's something that is more important than the work we're doing. If it is more important than what we're currently doing we can stop the container with the understanding that we'll get back to it once we've handled the interruption. If it's not more important then we can agree (both with whomever is interrupting, or ourselves) that our focus needs to be here, with the work, until the container ends. We'll be able to give that other thing our full attention and not try to split our attention between the two.

This may seem like a simple delineation but putting it into practice can be challenging, especially if the culture you're in is about immediate results.

I don't have good answers if your culture demands your attention at all times. The best I can offer is that the containerized approach at least gives you some periods of concentration. But if you feel constantly on-guard because something might happen at any moment you're going to be less effective than if you have the ability to shut the world off for a bit. I'd also challenge you to see if that perception is really true: are you constantly being ambushed by interruptions? Testing that theory may be in order. Keep a sheet of paper (or put it into a text file, spreadsheet or database) with when you did a focus container and if it was interrupted or not. If you find that you are getting interrupted more often than not then you need to reassess what is causing the interruption and if it's something that you can control. There are many ways to handle workplace distractions that I won't go into here but being mindful of the distractions and where they are coming from will be key to figuring out how to mitigate them in the future.