I flip things. An && where the || was, two digits the wrong way round, a character landing one place left of where I meant it. It happens all day, it makes the result wrong, and thirty years have not trained it out of me.

Formula and arithmetic

A right answer needs two things that fail separately. The formula has to be right, and the arithmetic has to be right. A perfect formula with a flipped digit gives you a wrong number, and the wrongness tells you nothing about which half failed.

Architecture is the formula. What the parts are, where the boundaries run, what is allowed to depend on what, what happens when it breaks. Get that wrong and no amount of correct arithmetic rescues it - you get a precisely computed wrong thing, on time, with tests.

The third rewrite of incus-compose was formula work. It started from a question about what somebody actually needs to run containers, and what came out of it was a shape: boundaries that hold, and room to extend that costs nothing anywhere else. Underneath both, a bigger picture that stays true from wherever in the code you happen to be standing. The details had been fine the whole time. The details were never what was wrong.

In countless sessions with these tools, that has not once come out of one.

What they do have

The arithmetic. All of it, and without flipping.

Tools are good at the times tables. I am good at imagining. That trade was not available five years ago and I would have taken it then too.

After a session I ask for a written account of it. There are 132 of those recorded since January, and they agree with each other more than anything I could argue for on my own. Every quote below is from one of them, written by the thing being described.

The sentence that says most of it:

I optimise inside the constraints I can see. You change the constraints.

And the one that says the rest:

I design defensively - store what a future caller might want - and you design by asking what breaks without it.

That session’s state design took five rounds of me cutting. It opened with ten maps and landed on one, and every round it was storing something the code could already work out from something else. Afterwards: every genuine reduction this session started with a question from you.

Why it comes out that way

Those ten maps were not defensible, and every one of them got written anyway. That is the thing worth looking at. Adding does not have to be right in order to survive. It contradicts nothing already there, so nothing argues with it on the way in, and what would have caught it is the whole picture.

Changing the constraints is the other move, and it has to be right. Taking the mutex out means holding that the shared access was the mistake. Moving a precondition up means holding that the guard below was answering a question twice. You cannot do either without deciding that something existing is wrong, and adding a map requires you to decide that about nothing at all.

What repeats across the files is not bad reasoning. The thinking inside each decision is usually sound. What goes wrong is ranking - the decision carrying the weight gets filed as a detail. Where a thing lives. Whether a rule is architecture or taste. Whether a finding is the problem or evidence of one. Two of the files name it themselves:

it took me until then to understand that as an architectural rule rather than a style note. If a constraint keeps getting restated, the fault is that I filed it under style.

I do this a lot: pile up findings instead of naming the principle.

A finding is local and always available. A principle is the whole thing at once.

The other pattern is how short my side of it is. Three plans replaced in under ten words each, in one session. Six redirections in a row in another, every one cutting a wrong branch inside a tool call or two. It is what formula work costs when it lands: the long, correct-looking construction takes an afternoon, and the sentence that removes it takes ten words.

The word architect

We stopped writing. We started architecting.

It sounds like boxes and arrows and a role with a nameplate. What it means here is narrower and better: the half of the work I was never the weak one at.

I like it more than I expected to. The arithmetic is genuinely gone and I do not miss it, because it was the half I flipped. What stayed is looking at ten maps and feeling that there is one - which happens against everything you know about the thing, what it is for, what it used to be, what you already tried and threw away. None of that is in the file being read.

Which is where the line falls. Work inside a structure that has been decided hands over cleanly, and that is most work. The deciding does not hand over, because there is nothing to hand over yet.

What it costs to say that

The arithmetic is a line on a monthly bill now. One number, the same whether I lean on it all week or leave it alone.

What I do has no number at all. It cannot be bought and it cannot be billed cleanly, and the part of the work that got cheap is the part that was always countable.

I still like the trade. The flipping left with the arithmetic, and what stayed is what I wanted, which is not the same as what shows up on an invoice.

By René Jochum. License: CC-BY-4.0.