202510030947 Systems Software in the Large

#source #new

Big ambitious projects — in particular ones that are hard to make incremental progress on — always feel "a year away" because it is easy to make decisions in the day-to-day that don't make progress.

So how do we keep focus, prioritize (and critically deprioritize) work, and sequence the work?¹

One enemy: "organizational procrastination"

• Next step is not clear and there are lots of other important problems that are clearly valuable to solve. So we don't do the small increment for the big thing that isn't as clearly valuable and choose to do the valuable other thing that doesn't move us toward the long term goal.
• How to avoid letting dozens of small, well-understood problems starve work on the big, hard problems.
• This is a balance. Being responsive to changing priorities is important too.

Losing focus

• We get stuck on technical things
• We don't know what the next step is
• We run across other important problems (or they're thrust upon us. e.g., customer issues)

Maintaining focus

Daily optional water cooler (not meeting)

• Low-pressure way to surface issues that are keeping people stuck
• Goal is to feel more like working next to people
• It's not where we make big decisions
• It's truly optional
• Extended silence is fine

Making a path

Spend time making sure the next thing to do is obvious so we don't get stuck on the "what's next?" question. This provides clarity.

Demo!

• Planning them forces prioritization
• Demoing usually represents a big point of de-risk
• Inspires follow-up work, sustains momentum, generates feedback.
• Communicates with everyone else technically and in the business about progress
• Demos don't have to be cool

Prioritization

• 202206112310 Work on what matters
• 202106241531 Eisenhower matrix of task value
• 202206112313 Stop preening
• Is fixing this more important than taking the next step on the big thing? "Fully solve one problem" vs "make small progress on a big problem".
• Not always clear what the answer is.
• Next iteration only needs to be minimally as good as what we have today, not solve every problem.
• Ask what could we ship in 2 weeks? What constraints/scope/etc. would we have if we shipped in 2 weeks? Do that and iterate.
• 202510020919 Figure out if non-blockers have architectural impact
• Critical that when you deprioritize, you're explicitly agreeing to the impact of what happens when that bad thing does happen. You are not saying, we're going to put our heads in the sand for now and treat it as a miss/fire-drill when it happens.
• How do we prioritize big stuff? Cross cutting projects?
• How do we track risks and important non-blockers?

Reduce scope

• There is almost always more room for constraining projects and cutting scope than we suspect.
• This is not cutting back on rigor
  • Every system has operational limits (even the most fault tolerant computer systems cannot survive all the computers not having power)
  • The system is at a specific capability (say x) today, so if we ship x + 1, that's a win and we don't need to worry about x + 100 or perfection.
  • Use the deliverable of "this works on a sunny day"

Sequencing work

• Write down a data structure or interface that people can work to. Know that it will change, but it gets people moving.
• Find pieces that are in the critical path and tackle those as soon as possible.