I guided Claude Code to build a fuzzer for Obsidian Sync without ever reading the code myself.
I got a functional prototype in ~30h, saving an estimated ~10h.
Then I tried to finish it off, and the next ~30h turned into a bug treadmill, where at each turn Claude broke as much as it fixed.
This is the experience report: what went wrong, why research (and Anthropic's own docs) suggest this is to be expected, how an YC-alum AI-tooling founder's public talks tell a similar story, and maybe how to salvage the good bits.
That percentage comparison is fascinating. Say only 1 fighter remains in a tunnel when all the civilians have been finally bombed out and sniped off. By that measure that would mean Hamas is what, 50 times larger than the USA's military?
And regarding the concept of architectural mismatch, that goes nicely with another thing I recently wrote about [1]: how applying embedded architectures in high-level languages (Java) seem to yield big gains AND surprise everyone. At the moment I considered it a "lack of vocabulary" in Java, but now I realize that maybe the problem is a bit deeper/more general.
Java's architecture (and architecture idioms) might cause a blind spot (or is it a kind of Someone Else's Problem?); while C's architecture/tools or lack thereof disincentivize overwrought (or plain sophisticated) systems, for good and for bad.
Or more succinctly, Java makes you stop thinking about how things actually work, while C makes you stop thinking about how things should work.
Regarding [3], I find the paper interestingly underwhelming. Brooks' part of it says that 2 decades have passed (since NSB in 1986) without an order-of-magnitude improvement, and then says "Of the candidates enumerated in “NSB”, object-oriented programming has made the biggest change, and it is a real attack on the inherent complexity itself."
I think this is rather ironic / off-mark, given that the 90s and 00s were so full of OOP - for example, growth of C++ impulsed by Windows, and if anything OOP lately seems to be (thankfully) going back to being just another tool in the toolbox. To me it feels like OOP had its moment/decades in the spotlight, it didn't fulfill hopes/expectations/SB and therefore things keep moving on, in search of that SB. Isn't it?
Or is the implication that things were even worse in the 80's?
Note, I'm referring to OOP in the "industry standard" way it's commonly understood, not Alan Kay's message-passing original meaning - about which I'm still trying to learn more.
But, WOW - I just read David Lorge Parnas' part in [3]. I was already reeling from the paper's distilled self-serving, but this guy is crapping in every one, rather directly, and making sense while at it. I have a new hero to research.
[4 - 7] are really interesting, thank you (as is Betley's and McIlroy's mention). And also very interesting to see someone working in those things while developing another iteration of Smalltalk. This is really making me prioritize learning Smalltalk in my to-do queue...
I found this interesting, so after some googling, these are the numbers I found:
QNX kernel = 23 KLOC, C [1]
Plan9 kernel = 50 KLOC, C [2]
Squeak VM = 9 KLOC, Smalltalk [3] (Squeak is a Smalltalk)
Note, those are the kernels - Smalltalk's 20 KLOC include the whole system (GUI, etc), IIRC.
For clarity, I'm a bit out of my depth here, and I'm assuming that the Squeak VM is a bit akin to a kernel. And surely one could find more authoritative references for it all.
When it was discovered by the Mathematics community it was met with bemusement. Sorry, I'm recalling from memory here from years ago when I was a graduate student in Mathematics and don't have ready posts.
Actually, I think that talking about Java's multithreading here is a red herring; note that LMAX had to abandon multi-threading because it was destroying performance.
And this is important, because they explicitly made a very interesting point of current architectures being at odds with current thinking about best practices for concurrent programming.
"If you program it like it was C then you can get good performance" -> Note that one of the points of the post is that just using "like C" won't magically fix your performance!
If anything, you could say "If you program it like a system with limited memory then you can get good performance". That, I can imagine being a universally applicable thing.
My point is that, for example for the particular case of memory management, there is an associated cost, whatever your language is; and you need to deal with it. Ignorance of the law is no excuse, etc.
Then I tried to finish it off, and the next ~30h turned into a bug treadmill, where at each turn Claude broke as much as it fixed.
This is the experience report: what went wrong, why research (and Anthropic's own docs) suggest this is to be expected, how an YC-alum AI-tooling founder's public talks tell a similar story, and maybe how to salvage the good bits.