[josephg]

I'll be honest; I've never understood this mindset. The idea of purposefully interrupting my flow every 25 minutes, explicitly dropping my context is ghastly. If you could design an ideal hell for me it would involve hard, interesting programming problems and constant (every ~10-20 minute) seemingly random external interruptions. (Its not an accident that I don't have children.)

Most of the work I'm really proud of happens in 1-1.5 week long coding binges, during which I code ~14 hours a day, don't eat well and don't get outside much. During that time my entire being is oriented around the problem. I sleep when I'm too tired to be productive and wake up with the problem spilling out of me.

I usually need a couple of weeks recovery time afterwards during which I'm pretty useless for anything thats not light and fluffy. But that time is 100% worth it. If I could work at that intensity for 1 week out of each month I'd be more productive than I have been at any 9-5 job I've ever had. Well, for a given definition of productivity.

So I guess I like pomodoros - I just think they should be about 1 week in length.

[shamano]

"From a practical standpoint, our research suggests that, when faced with long tasks (such as studying before a final exam or doing your taxes), it is best to impose brief breaks on yourself. Brief mental breaks will actually help you stay focused on your task!”

http://psychcentral.com/news/2011/02/09/taking-breaks-found-...

[erikpukinskis]

I think it suits your style of programming. My guess is you work in large repositories where you need to keep many complex data structures in your head in order to reason about what the code is doing. That's quite a common way of programming, and it does necessitate large blocks of undistracted time.

The Pomodoro/25 minute approach your OP is advocating I think requires that you write software a different way. You can't write big source files that reference hundreds of data structures. You can't write modules that require other modules to be structured just-so in order for things to work. You can't throw hundreds of views, models, etc, into a big repo and let them all call each other. You have to spend time constantly creating new interfaces, shuffling responsibilities around, and generally keeping your codebase such that no particular module requires you to reason much about the modules other than its few neighbors.

Frameworks tend to discourage this way of programming, because they want to give you a small set of primitives and have you fit everything into one of those boxes.

But if you can manage it, by avoiding frameworks, learning about all of the component systems available to you, and getting comfortable writing your own middleware, the 25 minute requirement can actually help you, since if you find a problem that you can't wrap your head around in 25 minutes, you know your next task is to move some module boundaries around so that you can get a clearer view of the problem.

Many software teams choose to operate on the bleeding edge of "could a very smart, full-time programmer with a lot of coffee understand what's happening after poking around for a couple hours?" rather than "does this interface create a region of the codebase which can be independently understood?"

[josephg]

80% of the programming I do is the style you suggest. But ... software development has bifurcated into two skills, and we don't yet have the words to differentiate them.

- There's the technician skill, where you poke at your react elements and fiddle with CSS until it looks like the mockup the designers gave you. Every 20 minutes you need to trawl through stackoverflow to find the exact way to use flexbox to get the layout you want, or to work around a bug in safari. When you're done you do some refactoring and feel good about it and call it a day.

- And there's the engineering skill, where you scratch your head and read wikipedia & some academic papers until you know what search terms to use. And then you realise that really you want something like an invertible bloom filter, except there's some small % chance it will fail each time you query it so you need a fallback mechanism. Except then you realise that fallback mechanism will have O(n^2) - but if you use a slightly different data structure then it'll become O(nlogn + klogk). But that requires modifications to the bloom filter itself and a funky network protocol, so you write that.

If the only programming you do is the first type, thats fine. Thats where we all start. Thats the majority of work out there. 25 minute pomodoros are probably fine for that. I like pair programming, because I can stay focussed better with a friend. Sometimes I listen to excited music while I work.

But all the work I'm most proud of is the second type. I wrote a streaming incremental compiler for a 2d air pressure based language. I got 90% of the way to making an OT algorithm work for arbitrary JSON structures (including object move), only to realise that it absolutely needs conflict markers so I put it down for awhile. I wrote a nodejs server from scratch thats compatible with google's browserchannel protocol - basically reimplementing TCP in the process. I implemented a PEG parser - and I'm going to need a session like this to add the ability to pass realtime streaming text updates through the parser.

These sorts of things can't be reduced to 25 minute context increments. They just need too much mental state. Maybe once they're done they can be broken down into pieces that you could explain in 25 minute chunks. But figuring out that some particular abstraction is the right one requires fitting the entire system together in your head, so you can turn it around. And thats a spacing out in the shower followed by a day with a whiteboard kind of task.

I guess the way I see it is that large amounts of uninterrupted time doesn't simply make it easier to do hard engineering. It makes it possible. Is that what the book refers to as deep work? If so then I think pomodoros are an anathema to that.

[erikpukinskis]

> But all the work I'm most proud of is the second type.

I think if that's true, you should spend your time structuring a back-end such that other people in the organization can take the "technician" stuff off your hands. People who care most about those parts of the codebase. Potentially even non-engineer. Start them in a read-only front end app. It doesn't get you out of the woods, because you still have to support all of those people. But your real job is doing the hard engineering work to create a robust framework which is safe for people to build on top of.

In the long term, you'll spend part of your time basically teaching, and the other part of your time doing that gnarly researchy stuff you love.

And you could eventually opt out of teaching too, if you found someone on your team who likes that work. Then you're just the wizard deep inside the machine making magic happen. Your teammates would probably help. Good people will take as much of the responsibility as they can, since they don't want you as a bottleneck anyway.

[ajmurmann]

Do you mind me asking if you are self-employed? The rhythm you describe very exciting, but impossible in most work places. What you are doing though is probably the only work pattern that surely qualifies as "a sprint".

[brachi]

> I just think they should be about 1 week in length. > I usually need a couple of weeks recovery time

And exactly like a real sprint (running very fast) a period of resting is necessary after such an effort, usually longer than the execution time spent.

[ajmurmann]

Yes! I couldn't agree more. I'm happy to sprint. If do it much rather than a marathon. But only if I get a break after it. Otherwise it's a marathon that you start out running like it was a sprint and fail.

[KurtMueller]

I would say you should adjust the timer to whatever fits your lifestyle.

I've always understood the pomodoro timers as 25 minutes of getting down into the trenches and then taking 5-10 minute breaks to think about whatever you're doing from a high level overview.

[beat]

I find that approach works best for about three days. I suppose three days of work is all my little brain can hold! Three days of crunch followed by one or two days of downtime is insanely productive for me.

[FallujahJane]

I think 25 minutes (or 20, in some versions) may be the ideal time period to get you started; not to get you to stop. It's easy to convince yourself to shut down your email, not look at any distracting websites, etc., if you can tell yourself that you have to keep it up for only 25 minutes. Once you get going, you may be able to work effectively and without distraction for a full hour, but if the pomodoro period were set to an hour to begin with, you might never have started.