Yet another Hacker News

21 points sklarsa 1 day ago 18 comments

delifue 1 hour ago | parent

When people refute the idea that "LLM is the new compiler from natural language to code" the common reason is that LLM is non-deterministic but compiler is deterministic.

But the determinism isn't the real distinction. LLM inference can be made deterministic (temparaute zero, etc.). And multi-threaded compiler can be non-dterministic.

And human developers are also non-deterministic. There is always the nondeterminism even before AI.

I think the real difference is how leaky the abstraction is. If you just need to understand language instead of compiler internal to write correct code, the compiler is non-leaky abstrction. If you rely on compiler to do auto SIMD optimization, and have to do hacks to trigger the optimization, compiler is leaky abstraction.

For AI, if you don't ever need to read the code and AI writes perfectly bug-free program that perfectly follows instruction, then AI is a non-leaky abstraction, but that's not the case for now. To make code maintainable and debuggable you still need to read the code if the project is complex enough.

hansvm 1 hour ago | parent

Yeah, it's not the non-determinism; it's that they don't do what I say. I can't imagine writing a nontrivial program without, at a minimum, reading and editing the pieces as they're being produced. People aren't complaining about non-determinism; they're complaining about the results being non-deterministically sometimes wrong.

ameliaquining 35 minutes ago | parent

And if they were deterministically sometimes wrong, that wouldn't be better.

bigstrat2003 30 minutes ago | parent

That actually would be significantly better, because then you could work out under what conditions they were wrong and correct for it. But being stochastically wrong means you have to check everything, because you never know when the errors will creep in.

ameliaquining 18 minutes ago | parent

If it were deterministic but chaotic, which AFAIK is the case for LLMs running at temperature 0, then you would have to likewise check every time you changed anything and couldn't meaningfully correct for it.

sigbottle 1 hour ago | parent

> I think the real difference is how leaky the abstraction is. If you just need to understand language instead of compiler internal to write correct code, the compiler is non-leaky abstrction. If you rely on compiler to do auto SIMD optimization, and have to do hacks to trigger the optimization, compiler is leaky abstraction.

Autovectorization is not a programming model!

I forgot who put me on that article - I think it might've been Horace He - but that is a pretty big idea in idea space for me.

xboxnolifes 41 minutes ago | parent

> And human developers are also non-deterministic. There is always the nondeterminism even before AI.

Pointing out humans are not deterministic is irrelevant to the comparison. In the original example of LLMs replacing compilers, the deterministic compiler is being replaced, not the non-deterministic human. In the original example, we move from non-deterministic human -> sourced code -> deterministic compiler, to non-deterministic human -> sourced prompt(?) -> non-deterministic LLM. The important part is the sourced code into a deterministic final step so your build artifact doesn't change.

You can point out you can change temperature to zero or what ever, but then you don't actually get the build artifact you wanted in the first place.

Olscore 16 minutes ago | parent

Decisions and intent are the leaks.

For AI correctness you need a decision ledger. The job appears to have shifted towards managing agents, and constraining them towards the right outcomes.

Working on it, open source: https://github.com/pullboard-dev/pullboard

kibwen 1 hour ago | parent

> One of my fundamental objections to LLM-driven software development was that model output is non-deterministic.

Model outputs are deterministic. Your API provider may be injecting untunable amounts of randomness, but if you're not at the whim of an opaque cloud service, your model can be as deterministic as you please.

The unease that you describe isn't about models not being deterministic (because they are), it's that generating outputs from LLMs is an inherently inductive process (operating backwards by extrapolating from observations and examples) rather than a deductive process (operating forwards from careful logical reasoning founded on axiomatic principles). Deductive processes are more reliable, predictable, and analyzable than inductive processes, but they're also much harder to produce for many classes of problems.

crystal_revenge 1 hour ago | parent

I'm so tired of the endless stream of articles that a.) don't know what "non-determinism" means in Computer Science and b.) don't really understand how LLMs work.

"Non-determinism" (i.e. the "N" in NP-Complete) does not mean "random", it means "following all paths at once" (there's a really elegant way to understand the List monad as representing non-deterministic computing). It's such a fundamental (and delightful) concept in computer science that refusing to understand what it means is a tragedy related to the loss of technical language itself.

But, even if we just sub "non-deterministic" for "inconsistent" or "random" or "stochastic" or whatever better term you come up with. Statements like the following just seem to not understand the basic architecture of LLMs:

> Given the same input prompt, a model's output is not guaranteed to be identical on every run, at least under normal running conditions.

"Normal running conditions"? The reproducibility of the output is 100% a property of how you choose to sample from an LLM. There are virtually endless ways you can define your sampler and whether or not the same result is reproducible is a fairly minor aspect of all the other choices you make when sampling.

At the end of the day, each step of the LLM gives you a distribution over next tokens, and you can do with that what you like.

In the end the article almost becomes a tautology: the output of an LLM represents a probability distribution over all the outputs it believes are valid with some variation around an expected output. Yes, that's literally what an LLM is.

ameliaquining 36 minutes ago | parent

The concept of determinism is useful in computer-science contexts other than automata theory. See, e.g., https://en.wikipedia.org/wiki/Deterministic_algorithm. It's not incorrect to use the term to refer to those things.

m10i 7 minutes ago | parent

> "Non-determinism" (i.e. the "N" in NP-Complete) does not mean "random", it means "following all paths at once" (there's a really elegant way to understand the List monad as representing non-deterministic computing). It's such a fundamental (and delightful) concept in computer science that refusing to understand what it means is a tragedy related to the loss of technical language itself.

You opened by expressing disdain for articles that misuse the term "non-determinism", then proceeded to give a definition that also misuses the term "non-determinism" in the given context, or at best is a bit too vague for anyone to gain insight from.

Here's a better definition:

An algorithm that can produce different outcomes, for the same input, on different executions.

jlkuester7 1 hour ago | parent

> LLMs, and their respective harnesses, are actors in a system. Code is just an output.

This tracks well with my experiences integrating AI into a software dev pipeline. Sure the output of an LLM is not deterministic in the same sense as a compiler (at least when the LLM has the typical configuration). However, that just means the LLM should not be solely responsible for the final product of your pipeline.

choonway 32 minutes ago | parent

the same way calculators replaced mental sums. not because it was sometimes faster, but that it was definitely more deterministic.

ramity 24 minutes ago | parent

I'm passionate about and talk about this topic a lot. A common misconception is the idea that temperature or entropy must be 0 when seeded entropy enables both creativity and consistency. Attention mechanisms, layer dropout, initial weights, all of it. It can all be driven by seeded entropy. These systems can and have been served in a deterministic manner, but there are a litany of economic drivers against doing so.

augment_me 6 minutes ago | parent

Orthogonal to the blog, but fun fact: Determinism is crucial for large-scale training runs, and effective RL-runs as it avoids collapse of numerics, but it costs more(about 10% perf) because you need can't parallelize over the batch nor use some specific instructions that dont guarantee reduction order in the way way. Horace He from Thinky has a great blog about this:

https://thinkingmachines.ai/blog/defeating-nondeterminism-in...

ares623 4 minutes ago | parent

The "determining" needs to happen elsewhere. Hint, it's a human somewhere. At best it's someone under your employ, or at worst it's some poor sap who's about to have a very bad day.

vel0city 1 minute ago | parent

The thing I think about most in this discussion of writing code and determinism is when I assign a ticket to a teammate. I don't expect a deterministic response from them. Ultimately speaking, they're going to make decisions outside of what I would have potentially done, and ultimately what's important is whether the code they write meets the deliverable requirements or not.

And yet so many people expect deterministic responses from llms while they're entirely okay with non-deterministic responses from teammates. It's just not how it's been done in the past to always expect deterministic code generation from humans