[skywhopper]

This article takes a very tiny, questionable bit of data and extrapolates a lot of iffy assertions.

In general I’m tired of the “humans need never, and should never look at the code” LLM triumphalism articles. Do these folks ever work with real systems, I wonder.

[dist-epoch]

I remember when "real programmers" were supposed to look at the assembly code generated by compilers because it was bloated, inefficient, and totally unsuitable to use in a real system.

Cue in "non-determinism" retort.

[tgv]

Hardware restrictions might have contributed to that. Anyway, analogs and metaphors do not prove what they sneakily try to imply. They might help thinking about a problem, but they leave out the actual argument, and in this case, the jump is substantial.

[chrisrhoden]

I think the problem is less determinism than predictability. Hashing algorithms are deterministic.

Will people start .gitignore-ing their src directories and only save prompts?

[ModernMech]

This article [1] would argue ”no”, because then you would be ridding yourself of a “repository of determinism”, which the prompts cannot replace.

You can build a system with non-deterministic properties but you need some sort of deterministic foundation to build working, usable systems. Non determinism from top to bottom is building on quicksand in a swamp.

[1] https://www.oreilly.com/radar/can-language-models-replace-co...

[zephen]

There are multiple reasons why binary repository managers like Artifactory exist.

And, arguably, the primary reason that perforce is still popular in some domains is that it works well with both large and opaque objects.

Once you've decided to version your src directory, whether a priori or because once bitten, twice shy, the next question is:

Is git the correct version control for this? Or are all the changes so large that git's advantages in merging and manually diffing things become irrelevant?

[dist-epoch]

https://github.com/dbreunig/whenwords

[keybored]

That you anticipated a retort isn’t enough. You also have to refute it.

Yeah compilers are deterministic and LLMs are not. The response to that?

The answer could very well be something like what’s in TFA namely formal verification. But an answer here is needed.

[dist-epoch]

Human programmers are not deterministic either - give the same spec/task to 3 programmers and you'll get three different implementations.

Yet somehow this didn't stopped a giant software industry existing.

[keybored]

I have millions of years of training data on the non-determinism or whatever of humans. That’s how, uh, humans can interoperate with humans.

[dist-epoch]

So you agree hard formal non-determinism is not required, just a sort of convergence of code and spec. Turns out LLMs can do this non-formal-deterministic human-deterministic programming too.

[keybored]

In my very first comment I made an openening for some kind of counter-argument, explicitly singling out the submitted piece here about formal verification. That you now seem to think that you are dribbling me into making some kind of concession that there might be use-case for LLMs here is beyond me.

I was asking you for a refutal, after all, not asking myself. Sarcastically pointing to compilers and meatbags in order to triumphantly conclude, aha so there’s a chance, isn’t quite it.