How the Pomodoro Technique changed my workday
fastcompany.com
fastcompany.com
So, I know it's not the best solution, but I keep compiling/loading time REALLY fast. I.e. hot reloading is a good example of small thing that boost productivity insanely. But even in C++, I'd just work on a separate project and stub everything so that it compiles in a few ms. I know that if I need to recompile the whole codebase everytime I'm making a change I won't get any work done.
It's also because I tend to do the code/test really fast. I know some people who code for a few minutes, then test it.. so it's less of a problem for them.
Anyway, back to my hacking.. see, that sucker took more than 5 seconds to run :-)
what kills my productivity is when it takes more than 5secs to compile/load/whatever.
Sigh. These kids today have no idea what it was like to dial in to work at midnight so you could fire off another build that could finish by morning, if you were lucky. Or, to be limited to off-hours for running builds at all.Of course, at that time, few companies were connected 24x7. My employer, for example, dialed in for mail and Usenet traffic exchanges a handful of times a day.
The debates over the first ANSI C spec in comp.lang.c were most entertaining.
I remember the joy when we got Cadence BuildGates to start running parallel synthesis and optimization runs. This allowed us to go from one build per week to two. If we were lucky!
It sure is hard to close that browser once it's all warmed up and full of interesting things though...
I've since added a bash alias that helps: `alias beep="echo -e '\a'"`
`burkemw3@laptop$ compile ; beep` makes sure I don't have that excuse anymore.
Edit: need to use `printf '\a'` for that
`defaults write com.apple.dock no-bouncing -bool TRUE && killall Dock`
I've found that I'm extra productive in lisp because I'm evaluating and compiling a single function at a time, usually. I can cycle between testing that one function and fixing/finishing it very rapidly since it never has to build or reload the whole thing. A lot of the time it doesn't even require leaving the editor.
Too bad I've so far only been able to use lisp on personal projects.
3/61 tests passed...
You have created a problem for yourself that should not exist: do not task switch to Hacker News, task switch back to your text editor to re-read the code you just added or to work on the next part of the problem; or you could be working on two parts of the project at once and keep rapidly flipping back and forth between them. Your issue is not that you don't have the patience to wait for five seconds: it is that during those five seconds you are doing something useless instead of something else important.
In all seriousness, once you stop thinking of "patience" as "I need to be able to sit on my hands and wait" and instead think of it as "I now have the opportunity to do something else for the next period of time that I should try to make as productive as I can", I don't think ADHD is the problem anymore: the issue is making sure you always have a fun productive side task. You might find yourself accidentally doing things you realize later had low value for the time, but at least you got something done, right?
Put another way, you should embrace ADHD, not fight it: once you get into the habit of distracting yourself with just another task, the 5-10 seconds of compile time no longer matters, as you routinely switch to another task for five minutes every time you compile and it doesn't matter how long the compile took. You can do this with everything: I deal with delays in my web page e-mail client by having two or more clients open at the same time where I am working on two different search and reply tasks.
If you think about it, some really complicated coding sessions require keeping the state of many pieces of the program in your mind simultaneously (see, e.g., this: http://heeris.id.au/2013/this-is-why-you-shouldnt-interrupt-... ), including code in many different files. This is actually more difficult cognitively than simply working on two separate simple and well-contained coding tasks simultaneously.
I haven't tried this for coding, but the equivalent would be not to start running a test until you know what the next function/method/commit you're going to make is. Even if you have to screw around looking for potential problems in your code, or potential places to refactor, don't run the tests until you know what that next thing is going to be.
Here's the actual Hemingway quote:
The best way is always to stop when you are going good and when you know what will happen next. If you do that every day when you are writing a novel you will never be stuck. That is the most valuable thing I can tell you so try to remember it.
I have the same experience as you do, and these numbers of 2 seconds and 6 seconds really seem about right. If the test runs in less than 2 seconds, I can stay focussed on what I'm doing. By 6 seconds, I'm already thinking about something else. My personal experience has been that if the tests takes longer than 2 seconds, it is virtually impossible to do TDD. Instead you have to write large chunks of code -- or at the very least write several tests in one go.
I'm fairly well known in my current group for the 2 second rule :-) 2 seconds is really a long time for a modern computer, so my feeling is that if you can't build and run a large section of tests in 2 seconds, you've got a serious problem somewhere. When pairing with people who don't mind longer test runs, I've noticed that they never actually TDD. Instead they right large pieces of code (entire functions at the very least), or they write 5-10 tests all in one go. When I show people the normal rhythm of TDD, they suddenly understand why you need to have incredibly fast tests.
I also preach a 2 minute limit for the entire test suite. Kent Beck has talked about that previously (although I can't remember what number he used -- something like 2-4 minutes). He has even advocated simply throwing away long tests. Test coverage is less important than being able to run your tests quickly. I have found that if the test suite creeps up to about 10 minutes, the frequency of running that test suite is reduced to about once per day -- meaning that you have totally lost the context of the problem when you discover it.
Whatever you need to do to keep those tests running quickly is what you should do. Whether that means only running a subset, hot loading modules, stubbing out slow moving pieces (even the database), etc. I could write for quite a long time on testing strategy... This needs to go on my queue for a blog post ;-)
I'm typically editing in parallel with tests running. This can frequently result in no down time whatsoever owing to tests, even during a large refactor. Let's say I make a big refactor and 90 different test classes break (this is not theoretical). I modify some code that might make one of those test classes past, kick of a test run, and immediately go edit another failing test class. By the time I think I've got that figured out, the test run on the first has completed, and I can either move on, or try something else to fix it if it's failed again. This requires keeping the state of multiple test classes in your head simultaneously, but fortunately I'm good at that.
It sounds a little heavy handed, but it made a huge difference.
This self-reflection and whatever series of events led to it are more valuable than any particular time management technique. I'm surprised the author did not discuss this in more depth, though I suspect this is because these realizations tend to arise largely by happenstance.
When we notice ourselves failing to direct our energy toward matters of immediate concern, this is a fine occasion to evaluate what we are doing and why. If it is procrastination, perhaps this is a result of fearing failure, or perfectionism, or low energy. Perhaps we are distracted by a thought with which we have too closely identified ourselves, thus failing to notice that we are even thinking. There are many competing forces at play in the mind, and we are seldom if ever aware of all of them at once. I think that generally the cause of low productivity is, as someone once put it, "a failure to think about thinking." Perhaps the boon of these techniques is that they direct our attention to the content of our minds by creating a sense of urgency.
I've found there are two advantages of Pomodoro that are under-appreciated:
1. At the end of your day you have an integer number of "Pomodoros" done. An integer number is very easy to grasp and compare with other days. So you have a very strong sense for how well you did with your day, or how well you are doing so far in the day. It's a powerful thing and it keeps you honest.
2. After you have used the technique for a while, the timer you use not only serves as a timer, but its start mechanism/button/gesture/whatever actually serves as some sort of psychological "switch" that puts your mind in work mode. On mornings when I am lacking a little motivation, I can just start the timer and I'll get into gear. It's not magic, but when I need a little extra kick the timer does it very well.
It remind me of the "This Is Why You Shouldn't Interrupt a Programmer" comic: http://heeris.id.au/2013/this-is-why-you-shouldnt-interrupt-..., except in this case, you're interrupting yourself.
These days, I use SelfControl to disable access to my distractions all day long to get a ton of stuff done.
The principle is to give you a small amount of time you have to focus. Then once you did that, everything else seems easier.
Pomodoro is not really a time management technique, rather a motivation/anti-procrastination technique. But OP is trying to sell his product so... buzzwords.
My solution was to try to swap out that context to disk :-) I'm back in software again and I've refined my techniques a bit. It's helpful for me because as I get older, I can hold less context in my brain than I used to be able to do anyway. There are 2 main places I store context: tests and TODOs.
I'll start with TODOs. I actually use Emacs org mode for TODOs. The best part about Org mode is that it is in a text editor. That means that I interact with it the same way that I interact with any other tool. It is also hierarchical, which means that I can embed TODOs within TODOs. Finally, it is folding, which means that I can ignore large sections of the TODO list, or move sections around with just a few keystrokes.
Basically, as I'm programming, whenever I have the thought, "Oh, I have to do this", it goes in the TODO (even if I'm just about to do it). You have to be terse because you don't want it to take more than 1 or 2 seconds to jot down. But terse is OK. I actually have 2 editors open -- one that I'm programming in and one with Org mode. I switch between windows in tmux. This is the fastest way for me, but if you use Emacs normally, then Org Capture might be faster.
Every time I finish something, I go back to org mode, mark it DONE and then reorder my TODO list. It only takes about 10 seconds to reorder the TODO list and it's useful time for me to think about what I'm doing.
The easier bit for keeping context is tests. As I'm getting near the end of the pomodoro, I make sure that I have a failing test. If everything is passing at the moment, I quickly write a failing test.
When I return from the pomodoro, the first thing I do is run the tests. This shows the failing test. At that point, I only concern myself with fixing that test. If you are used to doing TDD, then it usually only takes 30 seconds or a minute to fix the failing test. This is like a bit of a boot loader to get you back into the problem. After the test is finished, I go to the TODO and reorder them. Often it doesn't have to be reordered, but the act of thinking about priorities restores the context for me.
Currently, I'm doing some experiments where I am recording myself doing a large kata where I do one pomodoro per day (the ultimate in context killing). I don't have any conclusions yet, but the techniques I describe above seem to be working well.
I'm using Asciinema to record myself and it elides portions where you are idle for a certain number of seconds (I have it set to 2 seconds). In other words it removed bits where you are doing nothing for more than 2 seconds. By comparing the actual time spend to the length of the recording, I can see how long I was idle. At the moment, it seems to be averaging about 5 minutes for every 25 minute pomodoro. That doesn't seem to be excessive to me (since I am reading documentation and thinking occasionally).
The overall work ratio is lower (75% vs ~83%) but it's hard to put an qualitative efficiency metric when programming anyway so I'm not so worried.
This ratio also worked super well when writing my dissertation - the 5m break never felt like enough of a reward after.
(there is also a great Pomodoro extension for Gnome if you're running Linux).
I used to nap like that too, until I reduced my caffeine (one cup of coffee in the morning now) and started consistently getting 8-10 hours of sleep per night. I'm much happier and more productive than I ever was when I felt like I was constantly battling exhaustion with afternoon naps and coffees.
...
It's a joke, doublestealth is a start-up satire blog, the subhead "The blog of (probably fictional) Brad Bradstone the CEO of (possibly non-existent) Yellow Yellow. Remember, this is a parody." sort of gives it away if you aren't familiar with it.
Click here to get access to my free 32-page guide that explains my simple system in detail and includes worksheets, tools, and resources that you can print out and use. Save 23.3 hours each week and get more accomplished!
[1] http://g.fastcompany.net/multisite_files/fastcompany/imageca...
Actually as someone who mostly formed my study/focus skills during the age of distraction (Facebook, SMS, YouTube), I don't think this is trivial at all.
If I were to go all in on the Pomodoro Technique, I'm pretty sure have to start training myself from just 10 minute undistracted work sessions.
If I can't do a full one, I cut the next one down by 5-10 mins and try the shorter time period. If I CAN get that one done, I add 5 mins. Repeat until I'm down to 5 minute tasks or 25 min pomo's.
Pomello: https://chrome.google.com/webstore/detail/pomello/ahjnfakocp...
https://chrome.google.com/webstore/detail/toggl-button/oejgc...
The app is open source, you can download the code at http://github.com/potomak/tomatoes, or you can use the version running at http://tomato.es.
Taking a 5 minute break for every 25 mins of uninterrupted work seems to preserve 'flow state', dramatically increasing my productivity :)
https://chrome.google.com/webstore/detail/strict-workflow/cg...
It forces you to make sure interruptions are actually worth dealing with vs putting them off till after the timer is up.
I've noticed that time really distorts when you open a new tab for a "quick HN browse" or similar.
I pair it up with Toggl, a time tracking service online to keep reports of what I'm working on, and I find it a huge boon to my productivity and ability to justify the time I spend working on things.
With Pomodoro, I assigned each chapter one "pomodoro" (25-minute time period). At the end of that time, the chapter was done, whether I'd finished it or not. As the timer ticked down, I'd see it out of the corner of my eye and read faster, eventually just skimming the first sentence of each paragraph and maybe soaking in one or two details every couple paragraphs. When each chapter was done, I'd have a rough idea of what the main thrust was, and a fistful of details as well. I'm pretty sure I got a B+ on that book report, but I was just amazed I got it in on time at all.
So in this case, I found it useful as a way to complete a large, boring, segmented task in a quick-and-dirty-but-effective way. I wouldn't recommned it as a cure-all, but it's a good tool to have in your belt for certain kinds of tasks.
I too ended up in a similar situation in university where I needed to complete a large programming project in a single night, and I did it. Now granted, that was a fault of bad time management on my part, but using disciplined programming I was at least able to recover from it and complete the project. And I have had a few instances in the business world that had similar tight and tough deadlines that were NOT a result of time management failure on my part.
If there's a problem with blog posts like this one (and especially so for ebooks) it's that they'll feel a need to justify a cost/article by rambling at length when 5-10 bullet points would suffice. Maybe that's what you're unhappy about.
But the problem is not with discussing or coining a name for a method. Countless 'cutely named' methods have been successful in part because of their names, e.g. Crossfit, 7 Minute Workout, 4 Hour Work Week, Five and Two Diet, Paleo Diet, etc.