23 posts. See all tags.
— part 8 of Rust Beyond Systems Programming
Three ways to hand code around — a block that runs now, a closure that runs later, a function with a name — and how to choose. Tests that become a table. And conditional compilation: code decided before the program runs, and why that is safer than deciding it while it runs.
— part 7 of Rust Beyond Systems Programming
postres picks a default output name, and one run showed it can be wrong. Tests that say what right means, a regular expression that fails them twice, the fix that was in the standard library all along — and a rule that would have found it first.
— part 6 of Rust Beyond Systems Programming
Some and None turn out to be an enum — and not the kind Java has. Tagged unions, an Option that cannot pass for the value it might hold, inputs kept apart from the domain, and a Config the rest of postres can trust: private, settled once built, and named even when the user does not name it.
— part 5 of Rust Beyond Systems Programming
postres learns to listen, and we write no parser to make it happen: the command line described as a struct, a macro that writes the parser from it — help screen and typo suggestions included — and what structs, attributes and macros are, and why they make Rust feel like a high-level language.
— part 4 of Rust Beyond Systems Programming
An empty directory becomes a Rust project: why a file-to-file converter is shaped like a compiler, a library and a binary in one package, modules and who can see them, a manifest with no dependencies in it, two lines that let the build refuse undocumented and unsafe code, and CI on three operating systems from the very first commit.
— part 5 of The question CTOs are probably not asking: is our loop closed?
Everybody was told agents only write code. They also read, and reason about what they read, and for a product owner that changes the job: feasibility with the code cited, a prototype that costs what a drawing did, and what an organisation has to assemble — training, access, an environment, a budget nobody has to justify — before the loop before the loop can close.
— part 4 of The question CTOs are probably not asking: is our loop closed?
A product owner who wanted to know whether their idea was even possible had one way to find out: interrupt somebody who was building something already decided. What that did to their work, why the two-line ticket was never laziness, and why the oldest fight in our industry was never about personalities.
— part 3 of The question CTOs are probably not asking: is our loop closed?
Around the loop a second time, and this time built for real: the two documents the spec turns out to be, the inner loop the agent runs alone while nobody watches, the checkpoint that is one command, the second read a machine does first, a merge nobody attends a meeting for, and the letters going back to the desk.
— part 3 of Rust Beyond Systems Programming
NullPointerException. Cannot read properties of undefined. ConcurrentModificationException. Segmentation fault. A tour of the failures that have nowhere left to happen once the types stop evaporating — and an honest account of the ones that stay.
— part 2 of Rust Beyond Systems Programming
The things you actually like about TypeScript, Java, Python and Go — unions, Optional, streams, lambdas, promises, channels, one command that builds everything — and where every one of them lives in Rust. No complaints in this one. Just the shape of an ordinary working day.
— part 1 of Rust Beyond Systems Programming
I learned Rust by building a bank in it, having never written a line of it before, while the corridor explained that Rust needs PhD-level programmers. What actually changed was not safety. It was relief: I stopped spending my day avoiding mistakes and got to spend it solving the problem.
— part 2 of The question CTOs are probably not asking: is our loop closed?
Four rules for the moment an agent takes the writer’s chair: why you do not get to wait this one out, why a team that waits for a nod is not using agents, the one sentence about control that this series hangs on, and what happens to every estimate you have ever given.
— part 1 of The question CTOs are probably not asking: is our loop closed?
Every trade has a loop between “it is written” and “it is right”. Ours too. We drew it, built half of it, and a person quietly did the rest. What that cost, and how I know. Spoiler: I was the person.
Cognition published a case study about EBANX and Devin, and I am most of the way through it. The number everyone will take away is twelve hours. This is about the month before them and the bet around them, which is the part a case study has no room for.
Thirteen commitments about working with AI, written down so that anyone who reads my code or my text knows the terms it was made under. The first of them is that this page was written by a machine, and that I answer for it.
— part 9 of You are now the whole team
Every mechanism this series has described, and the six things that beat them anyway — the wrong remedy for a right diagnosis, the machine that never complains, the gate that lied about itself, and the rule I was proudest of, whose hole an agent found and was entirely right about.
— part 8 of You are now the whole team
The architecture conversation that filled the twenty-six days: one reader-agnostic server, one bridge per screen reader in whatever language that reader dictates, and a decision to reject Rust for a reason I have never seen written down.
— part 7 of You are now the whole team
Twenty-six days between one commit on the terminal and the next, because every pull request cost me an evening of listening. What I built instead, and the four questions that separate this from procrastination.
— part 6 of You are now the whole team
What the method from last time actually produced, measured rather than asserted: where the hours went, how much had to be done twice, and the afternoon a machine that had never built any of this was ready in nine minutes.
— part 5 of You are now the whole team
What I actually typed on the first night, and why almost none of it was an instruction. Five moves, quoted from the record — including the ones where I told the agent I did not understand a word of what it had just proposed.
— part 4 of You are now the whole team
Five hundred and forty lines of documentation, six files, and not one line of code — then fourteen more commits before the first one. Six jobs got done that evening, and I did not notice I was switching between them.
— part 3 of You are now the whole team
Extrapolation is the whole reason you use an agent, and the whole risk of using one, because they are the same mechanism. So the question is never how to stop it — it is where it should be wide and where it must be narrow.
— part 1 of You are now the whole team
We were always the engineer and the bricklayer, because in software putting the walls up is itself an ultra-qualified job. Something else can lay the bricks now — which does not make you less of an engineer, it makes you only an engineer.