Thread by @GeePawHill

let's talk a little bit about showing your working code to your product person.

a basic recommendation, which will seem strange and likely freak you out the first time you hear it.

look to show your new stuff every day or two.

i want to address here both the how and the why.

the why has three parts: 1) just-in-time tuning, 2) food-pellets. 3) cross-specialty connection.

just-in-time tuning is just feedback. but i used an odd word, as i'm wont to, to keep you from instantly symbolizing the idea into something you think you already get.

one of the myths of software development is the idea that written requirements can or should fully specify what a program does. the trade is gradually backing away from this myth, but its shadow lingers on.

there's a trivial disproof: if you're a geek, your entire job is the translation of human language, which is neither precise nor complete, into computer language, which is both. doing this takes considerable human judgment. that's why they pay you for it.

written requirements can't specify an actual program because they can never be made as precise or complete as a program *has* to be to run. if they were that precise and complete, they would *be* a program, and we would be already done.

because requirements are imprecise and incomplete -- by *definition*, not failure of will or technique -- we want to operate around them with a continuous flow of conversation about variation, exempla, exception.

we need to be tuning our code and our understanding of what is wanted. we need to do that with a product person for the simple reason that they are experts in what is wanted.

(aside: product people aren't bosses, they're *experts*. working w/o one is like writing a gigantic web app w/o someone who is an network infrastructure expert. it's slow, dumb, and very very risky.)

the second why: food pellets. this angle on feedback never gets any press, i'm not sure why, except maybe people are taught to be blind to themselves.

didja ever have your product person go, "oh! cool." or even "yes, YES. that's it exactly."?

how did that make you feel?

i'm gonna go out on a limb and predict it made you feel pretty damned good.

i'll go out even further, and predict that it made you, for a short period after, more effective, more efficient, more energized, in short, a greater producer of value.

rats press levers to get food pellets. that's not cuz they're primitive. we *all* press levers to get food pellets -- or anything else that makes us feel good.

don't hate that about yourself. *use* it.

another stock myth for geeks: product people only care about big steps. this one i think comes from disregarding *their* human-ness, further muddied by the weird shaping pressure of stupid and irrelevant deadlines that they live under.

but your product person is a person, and she's creating a product through you. when you get something right, even something little, she's seeing *her* vision come true, even a little.

guess what: pellets.

yep. makes her feel good. increases her effectiveness, efficiency, and energy for a short time.

that "short time" thing is important. bigger steps don't make correspondingly longer-lasting highs. it's another myth. understand the risk of binge/starve mechanics.

so pellets is about getting your team -- including your product person -- a steady incremental supply of "feeling pretty damned good".

the third why i called cross-specialty connection, but it's really "teaming". teams have insides and outsides and borders, possibly gray slippery ones.

one of the easiest ways to form a team is to declare that everyone with attribute X is *in* the team, and everyone else is *out* of the team.

easy, but not useful.

modern software takes lots of specialties. modern lots of things do. i like the example of making movies. think of your favorite movie. do you know how many specialists collaborated to make that movie?

the precise number: scads and scads.

aside: geeks know this on one level but ignore it on others. i know of few teams that don't have "go to" people for the tricky specializations in their code. "go to sherry, she knows about how the threading works," for instance.

where do you want your product person to be? *inside* the team or *outside* the team?

i know where i want mine.

showing my code every day or two is a way of telling a shared story. shared stories are the next easiest way to make teams. and unlike team-by-attribute, team-by-narrative is actually useful.

so now we know why we want to share every day or two: 1) tuning, 2) pellets, 3) teaming.

but how should we go about it?

once again i might surprise you.

in the strongest possible terms i urge you not to schedule a recurring meeting.

1) use haykumeer protocol. 2) use any large screen in the workroom not a meeting room. 3) if you must be reminded, do it with a "days since" counter.

haykumeer protocol: "Hey, come here. I want to show you something." it's that simple. (i realize that some orgs make this very hard to do. we'll come back to that. in the meantime, just go with me.)

any big screen will do. grab one, plug it in, and show stuff. these sessions are short. we don't need chairs and tables and webex. we need engagement around what is on the screen. we need interaction.

(again, some orgs make this hard. go with me, problem-solving is next.)

days since: how can you know *when* you should use the protocol and show stuff? first of all, that's just an "in the beginning problem". once you start living this way, believe me, you'll know. why? cuz pellets. :)

but if you feel you must have a reminder, put a number up on the whiteboard: "hours since we showed stuff [ ]". increment it every morning at standup. what you're after here is a sense of rising tension, not a sense of impending deadline.

(aside: it's like TDD and CI once you get them going. there's no *schedule* to push. you just feel increasing tension and desire to push as the time stretches on.)

so there ya go.

why: 1) tuning, 2) pellets, 3) teaming.

how: 1) haykumeer, 2) workroom big-screen, 3) days-since.

i'd like to walk away, but i can't, yet, cuz i promised.

there are lots of orgs that make living like this difficult in various ways. it's not fair for me to just tell you to make it happen w/o giving some idea of what you're likely to press against and how to overcome it.

most likely issue: your org makes it impossible or very difficult to access a product person.

there's no short answer for this other than "don't do that". to add one more sentence to that, if you're not going to put product together with developers, you are absolutely not going to "do agile". if u need expert cites, ping me. i know dozens of product specialists who agree.

still, backing off from that, we still have two common difficulties: 1) product person lives in another place or even timezone. 2) product person is booked in outlook 19 hours a day every single day.

the answer for both of these is the same: block out a half-hour that's congenial to both parties every day. use it when you want to, don't use it when you don't.

we tend to think of outlook-allocated timeboxes as things we must fill. but it's not true. outlook works for you, you don't work for outlook.

i've never met a meeting-loaded person who wouldn't be delighted at having a mandatory half-hour slot at their desk that often *didn't* have a meeting, but sometimes did.

another common issue: there's no handy big monitor laying around unless we have a meeting in a conference room.

buy one, on a rolling stand. at less than a grand, it's chump change compared to the benefit it provides.

a very deep process issue: "we never have anything that goes from not showable to showable in a day or two."

of course, there is often staggering. once a team reaches a small critical mass, it's likely that *some* story will reach showability every day or two, even if most stories take more time than that.

but that's a dodge. a set of stories whose "time to show" mean is more than a couple of days is actually evidence that we have not gotten good enough at our job.

i have explained (and advocated) extreme increment and iteration (i&i) elsewhere, at length. it is central to the modern technical synthesis. if you're not yet able to do that, we need to work on that. hard. we need to work on that hard.

one more thought on these and other potential blockers to this way of showing your code every day or two. it's a generic thought, applicable to any and all political difficulties you might find in getting this all started.

as working geeks you are your orgs "makers making the made", & they are hopelessly dependent on you. because you sit on the 1st floor, you might think you've no power. this is the greatest myth in a myth-laden muse.

you have power to change. you just have to use it.

so. in conclusion: figure out how you are going to get to sharing your code with your product person every day or two. the benefits are enormous, the cost is minimal.

and for the threading impaired, here's the blog: "Showing Code Every Day or Two" geepawhill.org/showing-code-e…