7 ms·
The discussions around this point are taking it too seriously, even when they are 100% correct. LLMs are not deterministic, so they are not compilers. Sure, if
by codingdave 8mo ago
The discussions around this point are taking it too seriously, even when they are 100% correct. LLMs are not deterministic, so they are not compilers. Sure, if you specify everything - every tiny detail, you can often get them to mostly match. But not 100%. Even if you do fix that, at that point you are coding using English, which is an inefficient language for that level of detail in a specification. And even if you accept that problem, you still have gone to a ton of work just to fight the fundamental non-deterministic nature of LLMs.
It all feels to me like the guys who make videos of using using electric drills to hammer in a nail - Sure, you can do that, but it is the wrong tool for the job. Everyone knows the phrase: "When all you have is a hammer, everything looks like a nail." But we need to also keep in mind the other side of that coin: "When all you have is nails, all you need is a hammer." LLMs are not a replacement for everything that happens to be digital.
- alpaylan 8mo agoI think the point I wanted to make was that even if it was deterministic (which you can technically make it to be I guess?) you still shouldn’t live in a world where you’re guided by the “guesses” that the model makes when solidifying your intent into concrete code. Discounting hallucinations (I know this a is a big preconception, I’m trying to make the argument from a disadvantaged point again), I think you need a stronger argument than determinism in the discussion against someone who claims they can write in English, no reason for code anymore; which is what I tried to make here. I get your point that I might be taking the discussion to seriously though.
- liveoneggs 8mo agoThe future is about embracing absolute chaos. The great reveal of LLMs is that, for the most part, nothing actually mattered except the most shallow approximation of a thing.
- wizzwizz4 8mo agoThe great reveal of LLMs is that our systems of checks and balances don't really work, and allow grifters to thrive, but despite that most people were actually trying to do their jobs properly. Perhaps nothing matters to you except the most shallow approximation of a thing, but there are usually people harmed by such negligence.
- skydhash 8mo agoImagine if the amount of a bank transfer does not matter, but it can only be an approximation, also you can approximate the selected account too. Or the system for monitoring the temperature of blood stockage for transfusion… Often it seems like tech maximalists are the most against tech reliability.
- snovv_crash 8mo agoNo need to be so practical. I suggest when their pointer dereferences, it can go a bit forward or backwards in memory as long as it is mostly correct.
- SecretDreams 8mo agoLet's give people a choice. My banking will be deterministic, others can have probabilistic banking. Every so often, they transfer me some money by random chance, but at least they can say their banking is run by LLMs. Totally fair trade.
- wavemode 8mo agoWell, the person who vibe-coded the banking app also vibe-coded a bunch of test cases, so this will only affect a small percentage of customers. When it does and they lose a bunch of money, well, you have a PR team and they don't, so just sweep the story under the rug. Imagine that - you got your project done ahead of schedule (which looks great on your OKRs) AND finally achieved your dream of no longer being dependent on those stupid overpaid, antisocial software engineers, and all it cost you was the company's reputation. Boeing management would be proud. Lots of business leaders will do the math and decide this is the way to operate from now on.
- belZaah 8mo agoThis is true only for a small subset of problems. If you write crypto or hardware drivers, details do matter.
- holden_nelson 8mo agoI’m not an AI evangelical, but I think it remains to be seen what the size of that subset is. Those that write crypto and hardware drivers are certainly a small subset of programmers. Most of us are pumping out enterprise crud and arguing with our PMs.
- pjmlp 8mo agoGlueing SaaS systems together with low code tools, many of which now also have AI driven configurations.
- ModernMech 8mo agoI think the exact opposite is true: LLMs revealed that when you average everything together, it's really bland and uninteresting no matter how technically good. It's the small choices that bring life into a thing and transform it from slop into something interesting and worthy of attention.
- liveoneggs 8mo agoI think we agree but my prediction is that the slop will win
- blazinglyfast 8mo ago> even if it was deterministic (which you can technically make it to be I guess?) No. LLMs are undefined behavior.
- xixixao 8mo agoOP means “given the same input, produce the same output” determinism. This isn’t really much different from normal compilers, you might have a language spec, but at the end of the day the results are determined by the concrete compiler’s implementation. But most LLM services on purpose introduce randomness, so you don’t get the same result for the same input you control as a user.
- deleted 8mo ago[deleted]
- zaphar 8mo agoYou can get deterministic output if just turn the temperature all the way down. The problem is that you usually get really bad results, deterministically. It turns out the randomness helps in finding solutions.
- recursive 8mo agoYou can also get deterministic output if you use whatever temperature you want and use an arbitrary fixed RNG seed.
- raw_anon_1111 8mo agoBefore LLMs and now more than a decade ago in my career, I was assigned a task and my job was to translate that task into a working implementation. I was guided by the “guesses” that other developers made. I had to trust that they could do FizzBuzz competently without having to tell them to use the mod operator Then my job became I am assigned a larger implementation and depending on how large the implementation was, I had to design specifications for others to do some or all of the work and validate the final product for correctness. I definitely didn’t pore over every line of code - especially not for front end work that I stopped doing around the same time. The same is true for LLMs. I treat them like junior developers and slowly starting to treat them like halfway competent mid level ticket takers.
- seanmcdirmid 8mo agoDeterminism excludes guessing and any kind of non-algorithmic decision making.
- WithinReason 8mo agoLLMs are deterministic at minimal temperature. Talking about determinism completely misses the point. The human brain is also non-deterministic and I don't see anybody dismiss human written code based on that. If you remove randomness and choose tokens deterministically, that doesn't magically solve the problems of LLMs.
- SecretDreams 8mo ago> The human brain is also non-deterministic and I don't see anybody dismiss human written code based on that. Humans, in all their non deterministic brain glory, long ago realized they don't want their software to behave like their coworkers after a couple of margaritas.
- WithinReason 8mo agoYou seem to be under the impression that I'm promoting LLMs, not sure where you got that idea. The argument is that non-determinism has nothing to do with the issues of LLMs.
- CGMthrowaway 8mo ago>LLMs are not deterministic, so they are not compilers. "Deterministic" is not the the right constraint to introduce here. Plenty of software is non-deterministic (such as LLMs! But also, consensus protocols, request routing architecture, GPU kernels, etc) so why not compilers? What a compiler needs is not determinism, but semantic closure. A system is semantically closed if the meanings of its outputs are fully defined within the system, correctness can be evaluated internally and errors are decidable. LLMs are semantically open. A semantically closed compiler will never output nonsense, even if its output is nondeterministic. But two runs of a (semantically closed) nondeterministic compiler may produce two correct programs, one being faster on one CPU and the other faster on another. Or such a compiler can be useful for enhancing security, e.g. programs behave identically, resist fingerprinting. Nondeterminism simply means the compiler selects any element of an equivalence class. Semantic closure ensures the equivalence class is well‑defined.
- moregrist 8mo agoPerhaps you're comfortable with a compiler that generates different code every time you run it on the same source with the same libraries (and versions) and the same OS. I am not. To me that describes a debugging fiasco. I don't want "semantic closure," I want correctness and exact repeatability.
- SecretDreams 8mo agoAgree. I'm not sure what circle of software hell the OP is advocating for. We need consistent outputs from our most basic building blocks. Not performance probability functions. Many softwares run congruently across multiple nodes. What a nightmare it would be if you had to balance that for identical hardware.
- candiddevmike 8mo agoI wish these folks would tell me how you would do a reproducible build, or reproducible anything really, with LLMs. Even monkeying with temperature, different runs will still introduce subtle changes that would change the hash.
- bee_rider 8mo agoAre conventional compilers actually deterministic, with all the bells and whistles enabled? PGO seems like it ought to have a random element.
- 123malware321 8mo agowell considering you use components like DFA to build compilers, yes they are determenistic. you also have reproducible builds etc. or does your binary always come out differently each time you compile the same file?? You can try it. try to compile the same file 10 times and diff the resultant binaries. Now try to prompt a bunch of LLMs 10 times and diff the returned rubbish.
- sigbottle 8mo agoI think one of the best ways to understand the "nice property" of compilers we like isn't necessarily determinacy, but "programming models". There's this really good blog post about how autovectorization is not a programming model https://pharr.org/matt/blog/2018/04/18/ispc-origins https://pharr.org/matt/blog/2018/04/18/ispc-origins The point is that you want to reliably express semantics in the top level language, tool, API etc. because that's the only way you can build a stable mental model on top of that. Needing to worry about if something actually did something under the hood is awful. Now of course, that depends on the level of granularity YOU want. When writing plain code, even if it's expressively rich in the logic and semantics (e.g. c++ template metaprogramming), sometimes I don't necessarily care about the specific linker and assembly details (but sometimes I do!) The issue I think is that building a reliable mental model of an LLM is hard. Note that "reliable" is the key word - consistent. Be it consistently good or bad. The frustrating thing is that it can sometimes deliver great value and sometimes brick horribly and we don't have a good idea for the mental model yet. To constrain said possibility space, we tether to absolute memes (LLMs are fully stupid or LLMs are a superset of humans). Idk where I'm going with this
- whattheheckheck 8mo agoNow you know how directors and executives feel
- 9rx 8mo ago> LLMs are not deterministic They are designed to be where temperature=0. Some hardware configurations are known defy that assumption, but when running on perfect hardware they most definitely are. What you call compilers are also nondeterministic on 'faulty' hardware, so...
- vlovich123 8mo agoEven with temperature and a batch size of 1 and fixed seed LLMs should be deterministic. Of course batch size of 1 is not economical.
- troupo 8mo agowith temperature=0 and no context. That is, a clean run with t=0, pk=0 etc. etc. will produce the same output for the same question. However if you ask the same question in the same session, output will be different. To say the least, this is garbage compared to compilers
- 9rx 8mo ago> However if you ask the same question in the same session, output will be different. When isn't that true? int main() { printf("Continue?\n"); } and int main() { printf("Continue?\n"); printf("Continue?\n"); } do not see the compiler produce equivalent outputs and I am not sure how they ever could. They are not equivalent programs. Adding additional instructions to a program is expected to see a change in what the compiler does with the program.
- troupo 8mo agoIf you ask the compiler to compile the same input, it will produce the same output. With LLMs the output depends on the phases of the moon.
- 9rx 8mo ago> If you ask the compiler to compile the same input, it will produce the same output. As with LLMs, unless you ask for the output to be nondeterministic. But any compiler can be made nondeterministic if you ask for it. That's not something unique to LLMs. > With LLMs the output depends on the phases of the moon. If you are relying on a third-party service to run the LLM, quite possibly. Without control over the hardware, configuration, etc. then there is all kinds of fuckery that they can introduce. A third-party can make any compiler nondeterministic. But that's not a limitation of LLMs. By design, they are deterministic.