# The Maker Scheduler

Paul Graham has an essay, “Maker’s Schedule, Manager’s Schedule”, about how meetings devastate the productivity of writers and coders because they break up an otherwise long stretch of time in which to get absorbed in your work. Also, you have to remember to go to them, which messes with your ability to get absorbed in stuff as the meeting approaches.

Nerds: Can we solve that problem, with nerdery?

Say two people (two makers, that is) would like to meet. They shouldn’t be like “how’s 3pm Thursday?”, they should be like “let’s queue this up on the Maker Scheduler (TM)”.

The Maker Scheduler (makerscheduler.com, msched.com — currently just pointing to this document) would be some kind of [hands waving] tool that would interface with your calendars, or even with something like RescueTime or TagTime that knows when you’re absorbed in real work, to pick a minimally disruptive time for both of you.

This could of course get arbitrarily sophisticated but maybe there’s some small subset that could be implemented easily and be useful immediately?

What if queueing something on the Maker Scheduler meant a chatbot would occasionally ask you if you were up for a meeting right now? You could normally ignore it or snooze the pestering for as long as you wanted but eventually you and the person you want to meet with would both be like “yeah, I just finished another meeting and now would be a fine time to meet”. And so the bot would message you both that you should meet Right Now.

## Related Idea: Pingability Proxy

It would be nice to come up with a more structured mechanism for interrupting people. I feel like the current unstructured way is socially inefficient. Too much hesitation to ping someone in the first place and when you do, too much hesitation to defer a conversation. It’s just hard to say “I’m kind of concentrating now, let’s talk later.” Or it can be the other way around — people ping too promiscuously, or ignore pings that are actually urgent enough to warrant an interruption. Either way, it’s inefficient. Ideally you’d convey your preferences to a proxy agent that would wait till the time is right and then be like “hey, you two are both sitting in airports right now where you can’t really get much real work done, so you should chat now”.

What about this: When someone sends you a chat message consisting of “ping”, your proxy forwards it to the Pingability Service. If you have set your pingability to true with the Pingability Service then it just lets the ping through. If false, it stores the ping, waits for both you (the pingee) and the pinger to be pingable and then relays the original ping to you and replies on your behalf with a pong. In other words, it initiates a conversation between the two of you.

So how about combining this pingability proxy idea with the makerscheduler idea? You don’t have to remember to set your pingability — the bot determines that by asking you “when’s the soonest you’d potentially be pingable?”. You could ignore it, answer with an amount of time (when it would ask you again), or say “now”, in which case it would let any pings through.

Hackers who said they’d like a makerscheduler (see improvetheworld thread 2010.08.02): nate binkert, dan goldstein, john cox

### Concrete Proposal: Let’s try this just for IM conversations first.

If someone IMs you with “ping” then your IM client intercepts it (Bee and I wrote a plugin for Adium that made this easy) and adds the sender to a list.
At any time you can say “/pings” to see that list (who has pinged you when). [Or maybe that’s a bad feature if it encourages you to check for new pings obsessively.]
The makerscheduler bot would then periodically ask you
“when’s the soonest you’d potentially want to have an IM conversation?”
and you’d reply with an amount of time like “24 hours” or “now”.
If you specify a nonzero amount of time then the bot won’t bug you until then.
If you say “now” then it will let through a ping from the list, remove that sender from the list, and send a “ping” from you to the sender.
If that person was running the maker scheduler then that ping itself would be intercepted on their end.

This allows you to ping your co-hackers with impunity. They won’t be interrupted by your ping until they want to be.

Use case 1: Alice installs msched, Bob doesn’t. Alice never takes advantage of the ping postponing.

• Bob sends “ping” to Alice
• Alice’s msched intercepts it and (immediately) asks Alice “when’s the soonest you’d want to be bothered? (queued pings: {bob})”
• Alice answers “now” or “0h” (for “zero hours”) and the ping from Bob comes through. If there were other pings queued, msched would immediately repeat its question with the remaining queue

Use case 1 is essentially the status quo without msched. Just to point out that it can’t really make your IM experience worse.

Use case 2: Alice installs msched, Bob doesn’t. Alice uses it strictly for snoozing pings. Bob is oblivious.

• Bob sends “ping” to Alice
• Alice’s msched intercepts it and (immediately) asks Alice “when’s the soonest you’d want to be bothered? (queued pings: {bob})”
• Alice answers “5h” and msched simply sleeps for 5 hours and repeats its question
• Alice may keep snoozing msched but eventually she says “now” and the ping from Bob comes through. If there were other pings queued, msched would immediately repeat its question with the remaining queue.

Use case 2 is Alice getting utility from msched despite no one else using it, or even knowing she uses it.

Use case 3: Alice and Bob both use msched.

• Bob sends “ping” to Alice
• Alice’s msched intercepts it and (immediately) asks Alice “when’s the soonest you’d want to be bothered? (queued pings: {bob})”
• Msched puts Alice and Bob in each other’s queues
• 5 hours later Alice again sees the same prompt from msched and this time she says “now” (she could also choose to bypass and send something other than “ping” to Bob and bug him immediately)
• Now her reply ping goes through to Bob and the process repeats…
• Bob gets the analogous prompt, “when’s the soonest you’d want to be bothered? (queued pings: {alice})”
• They can keep snoozing each other indefinitely or eventually both say “now” and start talking

(Bethany says I should climb back out of this rabbit hole and we should just establish a convention like “Makers Meet Mondays”. Ie, write off Mondays as meeting day and never schedule anything for the rest of the week. But she also says this idea of batching interruptions as though they’re email is a reasonable one.)

(Alice Monday’s idea: remotely triggering tagtime-like pings for others…)

## Changelog

2010.08.02 dreeves proposes this to friends on his improvetheworld list
2010.08.25 we grab the domain names
2017.12.14 adds this changelog and flirts with the idea of actually building something