vetronauta

Mu.

Few months ago I was debugging an integration with a no-code library that ships code in a custom binary format. I still smile thinking at the following test I read

assertThrows(RuntimeException.class, () -> callFoo(notABinaryFile)); //well, foo library is very complex, obviously this test throws!

Do you have specific strategies on handling equivalent mutants?

If I understood correctly, the author had the agent perform manual mutation testing (write code, write passing tests, manually change the code to see some tests fail, then revert the change), rather than automated mutation testing. Why not use a mutation-testing framework and consider the build failed if a certain percentage of mutations are not killed?

The article claims that the agents didn’t actually use TDD or mutation testing. While it’s possible for an agent to ignore the TDD procedure even when instructed to follow it, it can’t ignore a build failure.

Currently a tiny fraction of what is formalizable is of interest to mathematics; maybe humans will stop doing "serious" mathematics, but mathematics is beautiful and we will not stop playing with math, like we did not stop playing chess.

I would love to see a theory in the spirit of Guerino Mazzola work, but for (combinatorial) games.

I was reading your comment, disagreeing with it but still feeling why this is a good comment. It just occurred to me that this is not science: science must be reproducible and this is just an historical report on artifact that will be unavailable soon.

https://en.wikipedia.org/wiki/Buddhas_of_Bamiyan https://en.wikipedia.org/wiki/List_of_destroyed_libraries

If writing code is tactics, architecture is strategy. The end goal is just the desired outcome.