I Tried to Stop Thinking Like a Programmer. The Programmer Won.
On accidentally turning your whole life into a codebase
The disclosure
I’ve been writing software for a long time. Long enough that something quietly happened to me that nobody warned me about. The job didn’t stay at the job. It followed me home, sat down at my kitchen table, started folding the laundry, and is now, apparently, writing this blog post.
This isn’t a complaint. It’s mostly a confession.
What programming actually teaches you
Strip away the syntax and the frameworks and the arguments about tabs versus spaces, and the craft is teaching you four things on repeat.
Find the pattern. Every problem looks new for about ninety seconds. Then you start seeing the shape of it. The same shape you saw last Tuesday in a completely different context. Your brain quietly builds a library of these shapes, and after a while, very little surprises you.
Build it once, use it everywhere. A good function does one thing well, and you reach for it for the rest of your life. You stop solving the same problem twice. You become slightly allergic to people who do.
Plan on paper before you touch the keys. The whiteboard isn’t a formality. It’s the cheapest place to be wrong. Ten minutes of drawing saves three days of building the wrong thing.
Think from the other side. Code is written for the person using it, not the person writing it. You start every project by climbing inside the head of someone who isn’t you. After enough years, that climbing becomes muscle memory.
These are perfectly reasonable engineering habits. The trouble is they don’t stay engineering habits.
Laundry is just an algorithm with a fabric softener
Watch me do laundry and you will see a programmer who has forgotten he isn’t at work.
The pile gets sorted first. Mine, my wife’s, the kids’, socks in their own little kingdom. Each pile is now a clean batch of similar inputs. I run the same operation on the whole pile, fold, stack, done, before moving to the next. No context switching. No reaching for the iron between a t-shirt and a pair of jeans.
Cooking is worse. Or better, depending on who you ask. I cut everything before the stove turns on. The moment something is simmering and the CPU has a free cycle, the dishwasher gets loaded. Garbage goes out while the rice cooks. The kitchen, viewed from above, is a small parallel-processing pipeline run by a man who claims he’s relaxing.
Loading the dishwasher is a religion in our house, and I am the high priest. Plates here. Bowls here. Glasses tilted exactly so. There is one correct way and seventeen wrong ones.
Why do this? Because once you have the pattern, the brain stops deciding. And when the brain stops deciding, the loathing goes with it. The chore becomes a rhythm. The rhythm becomes a kind of peace. You’re not doing dishes anymore. You’re running a tiny, clean little function, and it feels good every time it returns.
The empathy nobody warned me about
Here is the part I didn’t see coming.
When you spend years asking what does the user actually need, something rewires. You stop arguing from your own corner first. You start, almost involuntarily, by stepping into the other person’s shoes and looking around. Not because you are noble. Because you have been professionally trained to.
A friend complains about their boss. The programmer’s mind doesn’t pick a side. It opens two windows, runs the friend’s perspective in one, the boss’s in the other, and tries to find where the two specifications disagree. This is not therapy. It is debugging. But it produces something therapy aims for, which is the dawning realisation that the other person is, in their own world, also the protagonist.
Years of writing code for users you’ll never meet teaches you, by accident, to assume good faith. To assume the other person has reasons. To assume the bug is in the system, not in the human. It is the most useful side effect of a technical career, and almost nobody puts it on a CV.
The thing about not getting attached
Software is never finished. Anyone who tells you otherwise is selling you a course.
You ship version 1. Version 2 deletes half of version 1. Version 3 deletes half of version 2. The thing you stayed up till 3 a.m. building gets rewritten in a quarter by someone who wasn’t even at the company when you started. And you learn, slowly, sometimes painfully, not to mind.
You learn the work was never the artifact. The work was the thinking. The artifact is just where the thinking went to live for a while.
This is, if I’m honest, the most useful thing programming has done to me as a person. I don’t cling to versions of myself either. The me from five years ago has been refactored. The me from five years from now will refactor this one. The continuous deployment never stops. It’s fine. It’s the point.
People who can’t let go of the thing they made are miserable in software. They are also, I have noticed, miserable in life.
The conversational hazard
There is a cost to all this, and it is mostly paid by the people who have to talk to me.
My brain, in any conversation about a problem, is sprinting toward one specific door. What is the actual problem. Not the symptoms. Not the history. Not the cast of characters and who slighted whom in 2019. The problem. Define the inputs. Define the desired output. Then, and only then, can we talk about the function in the middle.
This is not how most humans converse.
Most humans, when they bring you a problem, are not bringing you a problem. They are bringing you a story about a problem, and the story is mostly about who is to blame. The boss is impossible. The sister-in-law is dramatic. The neighbour, again. By the time the storyteller takes a breath, we have a richly drawn cast and zero requirements.
The programmer in me, twitching, wants to say: I think you’ve described the cause. Can we talk about the problem? I have learned, the hard way, that this sentence ends most conversations. People do not always want the problem solved. Sometimes they want the story heard. Sometimes the story is the problem, and the telling of it is the fix.
I am still working on this one. The whiteboard, it turns out, doesn’t work on feelings.
A small, embarrassing admission
I tried, briefly, to stop. To leave the programmer at the office. To do laundry like a normal person, throw everything in, see what happens. To cook without a pipeline. To listen to a complaint without quietly diagramming it in my head.
It lasted about a week. The socks staged a revolt. The rice burned. A friend told me a long story and I caught myself, halfway through, drawing an architecture diagram of their family on a napkin.
So I gave up giving up. The programmer is not a costume. He is, at this point, the operating system.
If that’s the deal, fine. I’ll take the empathy. I’ll take the calm about things changing. I’ll take the laundry sorted by owner and the dishwasher loaded like a Tetris world record. I’ll even take the conversational awkwardness, mostly.
Once a programmer, always a programmer. The code runs in the background whether you like it or not.
I just wish it came with better error messages.