Although, while the compiler devs might know what was going on in the compiler, they wouldn't know what the compiler was doing with that particular bit of code that the FORTRAN developer was writing. They couldn't possibly foresee every possible code path that a developer might traverse with the code they wrote. In some ways, you could say LLMs are like that, too; the LLM developers know how the LLM code works, but they don't know the end result with all the training data and what it will do based on that.
In addition, to the end developer writing FORTRAN it was a black box either way. Sure, someone else knows how the compiler works, but not the developer.
maybe you have a wrong mental model on how compiler works then. I'm not a compiler developer, but usually I have a pretty good idea on what code gcc will generate for my C++: it is far from a black box.
Also compilers usually compose well: you can test snippets of code in isolation and the generated code it will have at least some relation to whatever asm would be generated when the snippet is embedded in a larger code base (even under inter-procedural optimizations or LTO, you can predict and often control how it will affect the generated code).
> I think you may be misreading my comment, then, because I know how LLMs work. Which part of my comment do you think shows that I don’t?
Your repeated comparisons to compilers in the context of determinism display a lack of understanding of compilers, LLMs and determinism. That's quite an impressive trifecta!
Unless you are expecting the definition of determinism to include this: https://news.ycombinator.com/item?id=47911524 ... you can't really be surprised when people call out your definition of determinism as completely and utterly wrong.
A compiler is a function `f(x) -> y`. For given x, a specific compiler will in actual use always result in the specified y. There is no currently used LLM that I am aware of that is able to do that for any non-trivial input.
An LLM is a function `f(x) -> P(y)`. For a given x, you get a probability of y as the output.
If you are still unable to acknowledge that there is difference between `f(x) -> y` and `f(x) -> P(y)`, then there really isn't any reason to continue this thread.
Although, while the compiler devs might know what was going on in the compiler, they wouldn't know what the compiler was doing with that particular bit of code that the FORTRAN developer was writing. They couldn't possibly foresee every possible code path that a developer might traverse with the code they wrote. In some ways, you could say LLMs are like that, too; the LLM developers know how the LLM code works, but they don't know the end result with all the training data and what it will do based on that.
In addition, to the end developer writing FORTRAN it was a black box either way. Sure, someone else knows how the compiler works, but not the developer.