12 ms·

LLMs bring new nature of abstraction – up and sideways

54 points by tudorizer 1y ago

oytis 1y ago
I don't get his argument, and if it wasn't Martin Fowler I would just dismiss it. He admits himself that it's not an abstraction over previous activity as it was with HLLs, but rather a new activity altogether - that is prompting LLMs for non-deterministic outputs. Even if we assume there is value in it, why should it replace (even if in part) the previous activity of reliably making computers do exactly what we want?
- dist-epoch 1y ago
  Because unreliably solving a harder problem with LLMs is much more valuable than reliably solving an easier problem without.
  - darkwater 1y ago
    Which harder problems are LLMs going to (unreliably) solve in your opinion?
    - dist-epoch 1y ago
      Anything which requires "common sense". A contrived example: there are only 100 MB of disk space left, but 1 GB of logs to write. LLM discards 900 MB of logs and keeps only the most important lines. Sure, you can nitpick this example, but it's the kind of edge case handling that LLMs can "do something resonable" that before required hard coding and special casing.
      - sarchertech 1y ago
        In that example something simple like log the errors, or log the first error of the same type per 5 minute block had some percent chance of solving 100% of the problem. And it’s not just this specific problem. I don’t think letting an LLM handle edge cases is really ever an appropriate use case in production. I’d much rather the system just fail so that someone will fix it. Imagine a world where at every level instead of failing and halting, everything error just got bubbled up to an LLM that tried to do something reasonable. Talk about emergent behavior, or more likely catastrophic cascading failures. I can kind of see your point if you’re talking about a truly hopeless scenario. Like some imaginary autonomous spacecraft that is going to crash into the sun, so in a last ditch effort the autopilot turns over the controls to an LLM. But even in that scenario we have to have some way of knowing that we truly are in a hopeless scenario. Maybe it just appears that way and the LLM makes it worse. Or maybe the LLM decides to pilot it into another spacecraft to reduce velocity. My point is there aren’t many scenarios where “do something reasonable 90% of the time, but do something insane the other 10% of the time” is better than do nothing. I’ve been using LLMs at work and my gut feeling saying I’m getting some productivity boost, but I’m not even certain of that because I have also spent time chasing subtle bugs that I wouldn’t have introduced myself. I think I’m going to need to see the results of some large well designed studies and several years of output before I really feel confident saying one way or the other.
  - oytis 1y ago
    OK, so we are having two classes of problems here - ones worth solving unreliably, and ones that are better solved without LLMs. Doesn't sound like a next level of abstraction to me
    - dist-epoch 1y ago
      I was thinking more along this line: you can solve unreliably 100% of the problem with LLMs, or solve reliably only 80% of the problem. So you trade reliability to get to that extra 20% of hard cases.
    - pydry 1y ago
      The story of programming is not largely one of humans striving to be more reliable when programming but putting up better defenses against our own inherent unreliabilities. When I watch juniors struggle they seem to think that it's because they dont think hard enough whereas it's usually because they didnt build enough infrastructure that would prevent them from needing to think too hard. As it happens, when it comes to programming, LLM unreliabilities seem to align quite closely with ours so the same guardrails that protect against human programmers' tendencies to fuck up (mostly tests and types) work pretty well for LLMs too.
  - furyofantares 1y ago
    I'm pretty deep into these things and have never had them solve a harder problem than I can solve. They just solve problems I can solve much, much faster. Maybe that does add up to solving harder higher level real world problems (business problems) from a practical standpoint, perhaps that's what you mean rather than technical problems. Or maybe you're referring to producing software which utilizes LLMs, rather than using LLMs to program software (which is what I think the blog post is about, but we should certainly discuss both.)
    - dist-epoch 1y ago
      > solve a harder problem than I can solve If you've never done web-dev, and want to create an web-app, where does that fall? In principle you could learn web-dev in 1 week/month, so technically you could do it. > maybe you're referring to producing software which utilizes LLMs but yes, this is what I meant, outsourcing "business logic" to an LLM instead of trying to express it in code.
  - deleted 1y ago
    [deleted]
- kookamamie 1y ago
  Funny, I dismiss the opinion based on the author in question.
  - Insanity 1y ago
    Serious question - why? I know of the author but don’t see a reason to value his opinion on this topic more or less because of this. (Attaching too much value to the person instead of the argument is more of an ‘argument from authority’)
    - kookamamie 1y ago
      Let's just say I think a lot of damage was caused by their OOP evangelism back in the day.
      - diggan 1y ago
        You don't think the damage was done by the people who religiously follow whatever loudmouths says? Those are the people I'd stop listening to, rather than ignoring what an educator says when sharing their perspective. Don't get me wrong, I feel like Fowler is wrong about some things too, and wouldn't follow what he says as dogma, but I don't think I'd attribute companies going after the latest fad as his fault.
        kookamamie 1y ago
        Perhaps. Then again, advocating things like Singleton as anything beyond a gloriefied global variable is pretty high on my BS list. An example: https://martinfowler.com/bliki/StaticSubstitution.html https://martinfowler.com/bliki/StaticSubstitution.html
        diggan 1y ago
        > gloriefied global variable is pretty high on my BS list Say you have a test that is asserting the output of some code, and that code is using a global variable of some kind, how do you ensure you can have tests that are using different values for that global variable and it all works? You'd need to be able to change it during tests somehow. Personally, I think a lot of the annoying parts of programming go away when you use a more expressive language (like Clojure), including this one. But for other languages, you might need to work around the limitations of the language and then approaches like using Singletons might make more sense. At the same time, Fowlers perspective is pretty much always in the context of "I have this piece of already written code I need to make slightly better", obviously the easy way is to not have global variables in the first place, but when working with legacy code you do stumble upon one or three non-optimal conditions.
felineflock 1y ago
It is a new nature of abstraction, not a new level. UP: It lets us state intent in plain language, specs, or examples. We can ask the model to invent code, tests, docs, diagrams—tasks that previously needed human translation from intention to syntax. BUT SIDEWAYS: Generation is a probability distribution over tokens. Outputs vary with sampling temperature, seed, context length, and even with identical prompts.
- dcminter 1y ago
  Surely given an identical prompt with a clean context and the same seed the outputs will not vary?
  - diggan 1y ago
    + temperature=0.0 would be needed for reproducible outputs. And even with that, if it's actually reproducible or not depends on the model/weights themselves, not all of them are even when all those things are static. And then finally depends on the implementation of the model architecture as well. I think the tricky part is that we tend to think that prompts with similar semantic meaning will give the same outputs (like a human), while LLMs can give vastly different outputs if you have one spelling mistake for example, or used "!" instead of "?", the effect varies greatly per model.
    - dcminter 1y ago
      Hmm, I'm barely even a dabbler, but I'd assumed that the seed in question drove the (pseudo)randomness inherent in "temperature" - if not, what seed(s) do they use and why could one not set that/those too? To your second part I wouldn't make that assumption - I can see how a non-technical person might, but surely programmers wouldn't? I've certainly produced very different output from that which I intended in boring old C with a mis-placed semi-colon after all!
      - diggan 1y ago
        > Hmm, I'm barely even a dabbler, but I'd assumed that the seed in question drove the (pseudo)randomness inherent in "temperature" - if not, what seed(s) do they use and why could one not set that/those too? Implementations and architectures are different enough that it's hard to say "It's like X" in all cases. Last time I tried to achieve 100% reproducible outputs, which obviously includes hard-coding various seeds, I remember not getting reproducible outputs unless setting temperature to 0, I think this was with Qwen2 or Qwq used via Huggingface's Transformers library, but cannot find the exact details now. Then in other cases, like the hosted OpenAI models, they straight up say "temperature to 0 makes them mostly deterministic", but I'm not exactly sure why they are unable to offer endpoints with determinism. > I can see how a non-technical person might, but surely programmers wouldn't? When talking even with developers about prompting and LLMs, there is still quite a few people who are surprised that "You are a helpful assistant." would lead to different outputs than "You are a helpful assistant!". I think if you're a programmer or not matters less, more about understanding how the LLMs actually work in order to understand that.
dtagames 1y ago
I respect Martin Fowler greatly but those who, by their own admission, have not used current AI coding tools really don't have much to add regarding how they affect our work as developers. I do hope he takes the time to get good with them!
- diggan 1y ago
  > have not used current AI coding tools really don't have much to add regarding how they affect our work as developers I dunno, sometimes it's helpful to learn about the perspectives of people who've watched something from afar as well, especially if they already have broad knowledge and context that is adjacent to the topic itself, and have lots of people around them deep in the trenches that they've discussed with. A bit like historians still can provide valuable commentary on wars, even though they (probably) haven't participated in the wars themselves.
  - TZubiri 1y ago
    I agree, I don't use coding tools, "except to ask for a script to chatgpt every once in a while". But I experience it by reviewing and detecting LLM generated code by consultants and juniors. It's easy to ask them for the prompts for example, but when they use autocompletion based LLMs, it's really hard to distinguish source from target code.
nmaley 1y ago
I'm in the process of actually building LLM based apps at the moment, and Martin Fowler's comments are on the money. The fact is seemingly insignificant changes to prompts can yield dramatically different outcomes, and the odd new outcomes have all these unpredictable downstream impacts. After working with deterministic systems most of my career it requires a different mindset. It's also a huge barrier to adoption by mainstream businesses, which are used to working to unambiguous business rules. If it's tricky for us developers it's even more frustrating to end users. Very often they end up just saying, f* it, this is too hard. I also use LLM's to write code and for that they are a huge productivity boon. Just remember to test! But I'm noticing that use of LLM's in mainstream business applications lags the hype quite a bit. They are touted as panaceas, but like any IT technology they are tricky to implement. People always underestimate the effort necessary to get a real return, even with deterministic apps. With indeterministic apps it's an even bigger problem.
- CraigJPerry 1y ago
  Some failure modes can be annoying to test for. For example, if you exceed the model’s context window, nothing will happen in terms of errors or exceptions but the observable performance on the task will tank. Counting tokens is the only reliable defence i found to this.
  - danielbln 1y ago
    If you exceed the context window the remote LLM endpoint will throw you an error which you probably want to catch, or rather you want to catch that before it happens and deal with it. Either way, it's not a silent error that goes unnoticed usually, what makes you think that?
    - CraigJPerry 1y ago
      Interesting, the completion return object is documented but theres no error or exception field. In practice the only errors ive seen so far have been on the HTTP transport layer. It would make sense to me for the chat context to raise an exception. Maybe i should read the docs further…
alganet 1y ago
> This evolution in non-determinism is unprecedented in the history of our profession. Not actually true. Fuzzing and mutation testing have been here for a while.
- diggan 1y ago
  I think the whole context of the article is "program with non-deterministic tools", while non-deterministic fuzzing and mutation testing is kind of isolated to "coming up with test cases", not something you constantly program side-by-side with, or even integrate into the (business-side) of the software project itself. That's how I've used fuzzing and mutation testing in the past at least, maybe others use it differently. Otherwise yeah, there are a bunch of non-deterministic technologies, processes and workflows missing, like what Machine Learning folks been doing for decades, which is also software and non-deterministic, but also off-topic from context of the article, as I read it.
  - alganet 1y ago
    I just have a problem with his use of the word "unprecedent". This is not the first rodeo of our profession with non-determinism.
- TZubiri 1y ago
  Right, in testing, but not in the compiler chain
  - alganet 1y ago
    I don't understand what you mean. Can you elaborate on your perception of what a "compiler chain" is and the supposed LLM role in it?
    - TZubiri 1y ago
      A C compiler outputs x86 or ARM or whatever assembly. C is the source, x86 is the target code. Javascript is source code that might be interpreted or might output html target code (by Dom manipulation) Typescript compiles to javascript. Now javascript is both source and target code. If you upload javascript code that was generated by ts to your repo and you leave out your ts, that's bad. Similarly, an LLM has english (or any natural language) as it's source code and typescript (or whatever programming language) as its target code. You shouldn't upload your target code to your repo, and you shouldn't consider it source code. It's interesting that the compiler in this case is non deterministic, but it doesn't change the fact that the prompts are source code, the vibecode is target code. I have a repo that showcases this https://github.com/TZubiri/keyboard-transpositions-checker https://github.com/TZubiri/keyboard-transpositions-checker
smokel 1y ago
Abstractions for high-level programming languages have always gone in multiple directions (or dimensions if you will). Operations in higher level languages abstract over multiple simpler operations in other languages, but they also allow for abstraction over human concepts, by introducing variable names for example. Variable names are irrelevant to a computer, but highly relevant to humans. Languages are created to support both computers as well as humans. And to most humans, abstractions such as those presented by, say, Hibernate annotations, are as non-deterministic as can be. To the computer it is all the same, but that is increasingly becoming less relevant, given that software is growing and has to be maintained by humans. So, yes, LLMs are interesting, but not necessarily that much of a game-changer when compared to the mess we are already in.
bgwalter 1y ago
How many bandwagons has this guy jumped on? Now he says that LLMs will be the new high level programming languages but also that he listens to colleagues and hasn't really tried them yet. I suppose he is aiming for a new book and speaker fees from the LLM industrial complex.
somewhereoutth 1y ago
> As we learn to use LLMs in our work, we have to figure out how to live with this non-determinism. This change is dramatic, and rather excites me. I'm sure I'll be sad at some things we'll lose, but there will also things we'll gain that few of us understand yet. This evolution in non-determinism is unprecedented in the history of our profession. The whole point of computers is that they were deterministic, such that any effective method can be automated - leaving humans to do the non-deterministic (and hopefully more fun) stuff. Why do we want to break this up-to-now hugely successful symbiosis?
stpedgwdgfhgdd 1y ago
I’m programming software development workflows for Claude in plain english (custom commands). The non-deterministic is indeed a (tiny!) bit of a problem, but just tell Claude to improve the command so next time it won’t make the same mistake. One time it added an implementation section to the command. Pretty cool This is the big game changer: we have a programming environment where the program can improve itself. That is something Fortran couldn’t do.
- stpedgwdgfhgdd 1y ago
  (bit off topic, but I wished someone told me this a few months ago; for regular programming generation, use TDD and a type safe language like Go. (Fast compile times and excellent testing support). Don’t aim for the magical huge waterfall prompt)
dingnuts 1y ago
If LLMs are the new compilers, enabling software to be built with natural language, why can't LLMs just generate bytecode directly? Why generate HLL code at all?
- Uehreka 1y ago
  Why would the ability to generate source code imply the ability to generate bytecode? Also you wouldn’t want that, humans can’t review bytecode. I think you may be taking the metaphor too literally.
  - pixl97 1y ago
    I dont think they are... LLMs can learn from anything thats been tokenized. Feed enough decompiled and labeled data with the bytecode and it's likely the machine will be able to dump out an executable. I wouldn't be surprised if an llm could output a valid elf right now other than the tokens may have been stripped in pretraining.
    - bird0861 1y ago
      https://ai.meta.com/research/publications/meta-large-language-model-compiler-foundation-models-of-compiler-optimization/ https://ai.meta.com/research/publications/meta-large-languag...
  - skydhash 1y ago
    Because the semantic for each term in a programming language is pretty much a 1:1 relation to a sequential and logic-based ordering of terms in bytecode (which are still code). > Also you wouldn’t want that, humans can’t review bytecode The one great thing about automation (and formalism) is that you don't have to continuously review it. You vet it once, then you add another mechanism that monitors for wrong output/behavior. And now, the human is free for something else.
- VinLucero 1y ago
  I agree here. English (human language) to Bytecode is the future. With reverse translation as needed.
ptx 1y ago
> As we learn to use LLMs in our work, we have to figure out how to live with this non-determinism [...] but there will also things we'll gain that few of us understand yet. No thanks. Let's not give up determinism for vague promises of benefits "few of us understand yet".
- aradox66 1y ago
  Determinism isn't always ideal. Determinism may trade off with things like accuracy, performance, etc. There are situations where the tradeoff is well worth it.
  - pixl97 1y ago
    Yep, there are plenty of things that aren't computable without burning all the entropy in the visible universe, yet if you exchange it with a heuristic you can get a good enough answer in polynomial time. Weather forecasts are a good example of this.
    - josefx 1y ago
      Most heuristics are still deterministic.
    - betenoire 1y ago
      I understand there are probabilities and shortcuts in weather forecasts.... but what part is non-deterministic?
  - aradox66 1y ago
    Also, at temperature 0 LLMs can behave deterministically! Indeterminism isn't necessarily quite the right word for the kind of abstraction LLMs provide
    - josefx 1y ago
      That runs into the issue that nobody runs LLMs with a temperature of zero.
sgt101 1y ago
LLMs are deterministic. If you run an LLM with optimization turned on on a NVIDIA GPU then you can get non-deterministic results. But, this is a choice.
bwfan123 1y ago
Can authors of such articles at least cite Dijkstra's "On the foolishness of "natural language programming"." which appeared eons ago ? Which presents an argument against the "english is a programming language" hype. [1] https://www.cs.utexas.edu/~EWD/transcriptions/EWD06xx/EWD667.html https://www.cs.utexas.edu/~EWD/transcriptions/EWD06xx/EWD667...
- awb 1y ago
  Interesting read and thanks for sharing. Two observations: 1. Natural language appears to be to be the starting point of any endeavor. 2. > It may be illuminating to try to imagine what would have happened if, right from the start our native tongue would have been the only vehicle for the input into and the output from our information processing equipment. My considered guess is that history would, in a sense, have repeated itself, and that computer science would consist mainly of the indeed black art how to bootstrap from there to a sufficiently well-defined formal system. We would need all the intellect in the world to get the interface narrow enough to be usable, and, in view of the history of mankind, it may not be overly pessimistic to guess that to do the job well enough would require again a few thousand years. LLMs are trying to replicate all of the intellect in the world. I’m curious if the author would consider that these lofty caveats may be more plausible today than they were when the text was written.
  - bwfan123 1y ago
    > I’m curious if the author would consider that these lofty caveats may be more plausible today than they were when the text was written. What is missed by many and highlighted in the article is the following: that there is no way to be "precise" with natural languages. The "operational definition" of precision involves formalism. For example, I could describe to you in english how an algorithm works, and maybe you understand it. But for you to precisely run that algorithm requires some formal definition of a machine model and steps involved to program it. The machine model for english is undefined ! and this could be considered a feature and not a bug. ie, It allows a rich world of human meaning to be communicated. Whereas, formalism limits what can be done and communicated in that framework.
w10-1 1y ago
> I've not had the opportunity to do more than dabble with the best Gen-AI tools, but I'm fascinated as I listen to friends and colleagues share their experiences. I'm convinced that this is another fundamental change So: impressions of impressions is the foundation for a declaration of fundamental change? What exactly is this abstraction? why nature? why new? RESULT: unfounded, ill-formed expression
agentultra 1y ago
Abstraction? Hardly. What are the new semantics and how are the lower levels precisely implemented? Spoken language isn’t precise enough for programming. I’m starting to suspect what people are excited about is the automation.
- skydhash 1y ago
  But that's not really automation. It's more search and act based on the first output. You don't know what's going to come out, you just hope it will be good. The issue is that that the query is fed to the output function. So what you get is a mixture of what is a mixture of what you told it and what's was stored. Great if you can separate the two afterwards, not so if the output is tainted by the query. With automation, what you seek is predictability. Not an echo chamber. ADDENDUM If we continue with the echo chamber analogy: Prompt Engineering: Altering your voice so that the result back is more pleasant System Prompt: The echo chamber's builders altering the configuration to get the above effects RAG: Sound effects Agent: Replace yourself in front of the echo chamber with someone/something that act based on the echo.
abeppu 1y ago
I think we should shift the focus from adapting LLMs to our purposes (e.g. external tool use) and adapting how we think about software and focus on getting models that internally understand compilation and execution. Rather than merely building around next token prediction, the industry should take advantage of the fact that software in particular provides a cheap path to learning a domain-specific "world model". Currently I sometimes get predictions where a variable that doesn't exist gets used or a method call doesn't match the signature. The text of the code might look pretty plausible but it's only relatively late that a tool invocation flags that something is wrong. If instead of just code text, we trained a model on (code text,IR, bytecode) tuples, (byte code, fuzzer inputs, execution trace) examples, and (trace, natural language description) annotations. The model needs to understand not just what token sequences seem likely but (a) what will the code compile to? (b) what does the code _do_ and (c) how would a human describe this behavior? Bonus points for some path to tie in pre/post conditions, invariants, etc "People need to adapt to weaker abstractions in the LLM era" is a short term coping strategy. Making models that can reason about abstractions in a much tighter loop and higher fidelity loop may get us code generation we can trust.
- yuvadam 1y ago
  These types of errors are not only rare in one-shots, but also very easy to fix in subsequent iterations - e.g. Claude Code with Sonnet rarely makes these errors.
perching_aix 1y ago
> so I can't just store my prompts in git and know that I'll get the same behavior each time. Yes you can, albeit it's pretty silly to do so. LLMs are not (inherently) nondeterministic, you're just not pinning the seed, or are using a remote, managed service for them with no reliability and consistency guarantees. [0] Here, experiment with me [1]: - download Ollama 0.9.3 (current latest) - download the model gemma3n e4b (digest: 15cb39fd9394) using the command "ollama run gemma3n:e4b" - pin the seed to some constant; let's use 42 as an example, by issuing the following command in the ollama interactive session started in the previous step: "/set parameter seed 42" - prompt the model: "were the original macs really exactly 9 inch?" It will respond with: > You're right to question that! The original Macintosh (released in 1984) *was not exactly 9 inches*. It was marketed as having a *9-inch CRT display*, but the actual usable screen size was a bit smaller. (...) Full response here: https://pastebin.com/PvFc4yH7 https://pastebin.com/PvFc4yH7 The response should be the same over time, across all devices, regardless of whether GPU-acceleration is available. Bit of an aside, but the overall sentiment echoed in the article reminds me to how visual programming was going to revolutionize everything and take programmers' jobs. With the exception that AI I find actually useful, and was able to integrate it into my workflow. [0] All of this is to say, to the extent LLM nondeterminism is currently a model trait, it is substituted using a PRNG. Actual nondeterminism is at most an inference engine trait typically instead, see e.g. batched inference. [1] Details are for experiment reproduction purposes. You can substitute the listed inference engine, model, seed, and prompt with whatever your prefer for your own set of experiments.
- 0points 1y ago
  It's only deterministic with that exact model and that exact seed. So you are SOL unless you have a copy of that model.
  - perching_aix 1y ago
    And that exact prompt and that exact inference engine [version]. Pretty reasonable if you ask me. All of this was to say, these are still programs, all the regular sensibilities still apply. Heck, even for that, the sensibilities that apply are pretty old-school: in modern, threaded applications, you'd expect runtime behavioral variations. Not the case here. Even for the high-level language compilers referred to in the article, this doesn't apply so easily. The folks over at reproducible builds [0] put in a decent bit of effort to my knowledge to make it happen. The overarching point being that it's not magic: it's technology. And if you hold them to even broadly similar standards you hold compilers to, they are absolutely deterministic. In case you mean that if you pick anything else other than what I picked here, the process ceases to be deterministic, that is not true. You can trivially test and confirm that the same way I did. [0] https://reproducible-builds.org/ https://reproducible-builds.org/
gdubs 1y ago
The Star Trek computer – I grew up with TNG – is the example I always think of. They ask it in human language to pull up some data, create a visualization, run an analysis. You get the sense that people also still write programs in the future in a more manual way – but, done well these LLMs are the building blocks for that more conversational way of getting the computer to do what you want it to do. A lot of the complaints that come up on Hacker News are around the idea that a piece of code needs to be elegantly crafted "Just so" for a particular purpose. An efficient algorithm, a perfectly correct program. (Which, sorry but – have you seen most of the software in the world?) And that's all well and good – I like the craft too. I'm proud of some very elegant code I've written. But, the writing is on the wall – this is another turning point in computing similar to the personal computer. People scoffed at that too. "Why would regular people want a computer? Their programs will be awful!"
UltraSane 1y ago
a TLA+ model combined with a good LLM to generate code from it is the ultimate level of useful abstraction.
mrheosuper 1y ago
i have a "server" at home that host proxmox. On it there is 1 VM i used to test non-so-legal software, with no connection to internet or local network of course (hopefully proxmox virtual switch is good). I could say it's a lab, right ?
rkhalaf 1y ago
Now that machines can also follow natural language instructions, then programs can become a mix of code and natural language - using each where it makes the most sense. We looked into how we could blend this by integrating natural language within a programming system here https://blog.ballerina.io/posts/2025-04-26-introducing-natural-programming/ https://blog.ballerina.io/posts/2025-04-26-introducing-natur... and @bwfan123, we did cite Dijkstra as well as Knuth. I believe sometimes you need the rigor of symbolic notation and other times you need the ambiguity of language - it depends on what you are doing and we can let the user decide how and when to blend the two. It's not about one or the other, but a gentle and harmonious blending

54 points by tudorizer 1y ago

I don't get his argument, and if it wasn't Martin Fowler I would just dismiss it. He admits himself that it's not an abstraction over previous activity as it was with HLLs, but rather a new activity altogether - that is prompting LLMs for non-deterministic outputs. Even if we assume there is value in it, why should it replace (even if in part) the previous activity of reliably making computers do exactly what we want?

dist-epoch 1y ago
Because unreliably solving a harder problem with LLMs is much more valuable than reliably solving an easier problem without.
- darkwater 1y ago
  Which harder problems are LLMs going to (unreliably) solve in your opinion?
  - dist-epoch 1y ago
    Anything which requires "common sense". A contrived example: there are only 100 MB of disk space left, but 1 GB of logs to write. LLM discards 900 MB of logs and keeps only the most important lines. Sure, you can nitpick this example, but it's the kind of edge case handling that LLMs can "do something resonable" that before required hard coding and special casing.
    - sarchertech 1y ago
      In that example something simple like log the errors, or log the first error of the same type per 5 minute block had some percent chance of solving 100% of the problem. And it’s not just this specific problem. I don’t think letting an LLM handle edge cases is really ever an appropriate use case in production. I’d much rather the system just fail so that someone will fix it. Imagine a world where at every level instead of failing and halting, everything error just got bubbled up to an LLM that tried to do something reasonable. Talk about emergent behavior, or more likely catastrophic cascading failures. I can kind of see your point if you’re talking about a truly hopeless scenario. Like some imaginary autonomous spacecraft that is going to crash into the sun, so in a last ditch effort the autopilot turns over the controls to an LLM. But even in that scenario we have to have some way of knowing that we truly are in a hopeless scenario. Maybe it just appears that way and the LLM makes it worse. Or maybe the LLM decides to pilot it into another spacecraft to reduce velocity. My point is there aren’t many scenarios where “do something reasonable 90% of the time, but do something insane the other 10% of the time” is better than do nothing. I’ve been using LLMs at work and my gut feeling saying I’m getting some productivity boost, but I’m not even certain of that because I have also spent time chasing subtle bugs that I wouldn’t have introduced myself. I think I’m going to need to see the results of some large well designed studies and several years of output before I really feel confident saying one way or the other.
- oytis 1y ago
  OK, so we are having two classes of problems here - ones worth solving unreliably, and ones that are better solved without LLMs. Doesn't sound like a next level of abstraction to me
  - dist-epoch 1y ago
    I was thinking more along this line: you can solve unreliably 100% of the problem with LLMs, or solve reliably only 80% of the problem. So you trade reliability to get to that extra 20% of hard cases.
  - pydry 1y ago
    The story of programming is not largely one of humans striving to be more reliable when programming but putting up better defenses against our own inherent unreliabilities. When I watch juniors struggle they seem to think that it's because they dont think hard enough whereas it's usually because they didnt build enough infrastructure that would prevent them from needing to think too hard. As it happens, when it comes to programming, LLM unreliabilities seem to align quite closely with ours so the same guardrails that protect against human programmers' tendencies to fuck up (mostly tests and types) work pretty well for LLMs too.
- furyofantares 1y ago
  I'm pretty deep into these things and have never had them solve a harder problem than I can solve. They just solve problems I can solve much, much faster. Maybe that does add up to solving harder higher level real world problems (business problems) from a practical standpoint, perhaps that's what you mean rather than technical problems. Or maybe you're referring to producing software which utilizes LLMs, rather than using LLMs to program software (which is what I think the blog post is about, but we should certainly discuss both.)
  - dist-epoch 1y ago
    > solve a harder problem than I can solve If you've never done web-dev, and want to create an web-app, where does that fall? In principle you could learn web-dev in 1 week/month, so technically you could do it. > maybe you're referring to producing software which utilizes LLMs but yes, this is what I meant, outsourcing "business logic" to an LLM instead of trying to express it in code.
- deleted 1y ago
  [deleted]
kookamamie 1y ago
Funny, I dismiss the opinion based on the author in question.
- Insanity 1y ago
  Serious question - why? I know of the author but don’t see a reason to value his opinion on this topic more or less because of this. (Attaching too much value to the person instead of the argument is more of an ‘argument from authority’)
  - kookamamie 1y ago
    Let's just say I think a lot of damage was caused by their OOP evangelism back in the day.
    - diggan 1y ago
      You don't think the damage was done by the people who religiously follow whatever loudmouths says? Those are the people I'd stop listening to, rather than ignoring what an educator says when sharing their perspective. Don't get me wrong, I feel like Fowler is wrong about some things too, and wouldn't follow what he says as dogma, but I don't think I'd attribute companies going after the latest fad as his fault.
      - kookamamie 1y ago
        Perhaps. Then again, advocating things like Singleton as anything beyond a gloriefied global variable is pretty high on my BS list. An example: https://martinfowler.com/bliki/StaticSubstitution.html https://martinfowler.com/bliki/StaticSubstitution.html
        diggan 1y ago
        > gloriefied global variable is pretty high on my BS list Say you have a test that is asserting the output of some code, and that code is using a global variable of some kind, how do you ensure you can have tests that are using different values for that global variable and it all works? You'd need to be able to change it during tests somehow. Personally, I think a lot of the annoying parts of programming go away when you use a more expressive language (like Clojure), including this one. But for other languages, you might need to work around the limitations of the language and then approaches like using Singletons might make more sense. At the same time, Fowlers perspective is pretty much always in the context of "I have this piece of already written code I need to make slightly better", obviously the easy way is to not have global variables in the first place, but when working with legacy code you do stumble upon one or three non-optimal conditions.

felineflock 1y ago

It is a new nature of abstraction, not a new level. UP: It lets us state intent in plain language, specs, or examples. We can ask the model to invent code, tests, docs, diagrams—tasks that previously needed human translation from intention to syntax. BUT SIDEWAYS: Generation is a probability distribution over tokens. Outputs vary with sampling temperature, seed, context length, and even with identical prompts.

dcminter 1y ago
Surely given an identical prompt with a clean context and the same seed the outputs will not vary?
- diggan 1y ago
  + temperature=0.0 would be needed for reproducible outputs. And even with that, if it's actually reproducible or not depends on the model/weights themselves, not all of them are even when all those things are static. And then finally depends on the implementation of the model architecture as well. I think the tricky part is that we tend to think that prompts with similar semantic meaning will give the same outputs (like a human), while LLMs can give vastly different outputs if you have one spelling mistake for example, or used "!" instead of "?", the effect varies greatly per model.
  - dcminter 1y ago
    Hmm, I'm barely even a dabbler, but I'd assumed that the seed in question drove the (pseudo)randomness inherent in "temperature" - if not, what seed(s) do they use and why could one not set that/those too? To your second part I wouldn't make that assumption - I can see how a non-technical person might, but surely programmers wouldn't? I've certainly produced very different output from that which I intended in boring old C with a mis-placed semi-colon after all!
    - diggan 1y ago
      > Hmm, I'm barely even a dabbler, but I'd assumed that the seed in question drove the (pseudo)randomness inherent in "temperature" - if not, what seed(s) do they use and why could one not set that/those too? Implementations and architectures are different enough that it's hard to say "It's like X" in all cases. Last time I tried to achieve 100% reproducible outputs, which obviously includes hard-coding various seeds, I remember not getting reproducible outputs unless setting temperature to 0, I think this was with Qwen2 or Qwq used via Huggingface's Transformers library, but cannot find the exact details now. Then in other cases, like the hosted OpenAI models, they straight up say "temperature to 0 makes them mostly deterministic", but I'm not exactly sure why they are unable to offer endpoints with determinism. > I can see how a non-technical person might, but surely programmers wouldn't? When talking even with developers about prompting and LLMs, there is still quite a few people who are surprised that "You are a helpful assistant." would lead to different outputs than "You are a helpful assistant!". I think if you're a programmer or not matters less, more about understanding how the LLMs actually work in order to understand that.

dtagames 1y ago

I respect Martin Fowler greatly but those who, by their own admission, have not used current AI coding tools really don't have much to add regarding how they affect our work as developers. I do hope he takes the time to get good with them!

diggan 1y ago
> have not used current AI coding tools really don't have much to add regarding how they affect our work as developers I dunno, sometimes it's helpful to learn about the perspectives of people who've watched something from afar as well, especially if they already have broad knowledge and context that is adjacent to the topic itself, and have lots of people around them deep in the trenches that they've discussed with. A bit like historians still can provide valuable commentary on wars, even though they (probably) haven't participated in the wars themselves.
- TZubiri 1y ago
  I agree, I don't use coding tools, "except to ask for a script to chatgpt every once in a while". But I experience it by reviewing and detecting LLM generated code by consultants and juniors. It's easy to ask them for the prompts for example, but when they use autocompletion based LLMs, it's really hard to distinguish source from target code.

nmaley 1y ago

I'm in the process of actually building LLM based apps at the moment, and Martin Fowler's comments are on the money. The fact is seemingly insignificant changes to prompts can yield dramatically different outcomes, and the odd new outcomes have all these unpredictable downstream impacts. After working with deterministic systems most of my career it requires a different mindset. It's also a huge barrier to adoption by mainstream businesses, which are used to working to unambiguous business rules. If it's tricky for us developers it's even more frustrating to end users. Very often they end up just saying, f* it, this is too hard. I also use LLM's to write code and for that they are a huge productivity boon. Just remember to test! But I'm noticing that use of LLM's in mainstream business applications lags the hype quite a bit. They are touted as panaceas, but like any IT technology they are tricky to implement. People always underestimate the effort necessary to get a real return, even with deterministic apps. With indeterministic apps it's an even bigger problem.

CraigJPerry 1y ago
Some failure modes can be annoying to test for. For example, if you exceed the model’s context window, nothing will happen in terms of errors or exceptions but the observable performance on the task will tank. Counting tokens is the only reliable defence i found to this.
- danielbln 1y ago
  If you exceed the context window the remote LLM endpoint will throw you an error which you probably want to catch, or rather you want to catch that before it happens and deal with it. Either way, it's not a silent error that goes unnoticed usually, what makes you think that?
  - CraigJPerry 1y ago
    Interesting, the completion return object is documented but theres no error or exception field. In practice the only errors ive seen so far have been on the HTTP transport layer. It would make sense to me for the chat context to raise an exception. Maybe i should read the docs further…

alganet 1y ago

> This evolution in non-determinism is unprecedented in the history of our profession. Not actually true. Fuzzing and mutation testing have been here for a while.

diggan 1y ago
I think the whole context of the article is "program with non-deterministic tools", while non-deterministic fuzzing and mutation testing is kind of isolated to "coming up with test cases", not something you constantly program side-by-side with, or even integrate into the (business-side) of the software project itself. That's how I've used fuzzing and mutation testing in the past at least, maybe others use it differently. Otherwise yeah, there are a bunch of non-deterministic technologies, processes and workflows missing, like what Machine Learning folks been doing for decades, which is also software and non-deterministic, but also off-topic from context of the article, as I read it.
- alganet 1y ago
  I just have a problem with his use of the word "unprecedent". This is not the first rodeo of our profession with non-determinism.
TZubiri 1y ago
Right, in testing, but not in the compiler chain
- alganet 1y ago
  I don't understand what you mean. Can you elaborate on your perception of what a "compiler chain" is and the supposed LLM role in it?
  - TZubiri 1y ago
    A C compiler outputs x86 or ARM or whatever assembly. C is the source, x86 is the target code. Javascript is source code that might be interpreted or might output html target code (by Dom manipulation) Typescript compiles to javascript. Now javascript is both source and target code. If you upload javascript code that was generated by ts to your repo and you leave out your ts, that's bad. Similarly, an LLM has english (or any natural language) as it's source code and typescript (or whatever programming language) as its target code. You shouldn't upload your target code to your repo, and you shouldn't consider it source code. It's interesting that the compiler in this case is non deterministic, but it doesn't change the fact that the prompts are source code, the vibecode is target code. I have a repo that showcases this https://github.com/TZubiri/keyboard-transpositions-checker https://github.com/TZubiri/keyboard-transpositions-checker

smokel 1y ago

Abstractions for high-level programming languages have always gone in multiple directions (or dimensions if you will). Operations in higher level languages abstract over multiple simpler operations in other languages, but they also allow for abstraction over human concepts, by introducing variable names for example. Variable names are irrelevant to a computer, but highly relevant to humans. Languages are created to support both computers as well as humans. And to most humans, abstractions such as those presented by, say, Hibernate annotations, are as non-deterministic as can be. To the computer it is all the same, but that is increasingly becoming less relevant, given that software is growing and has to be maintained by humans. So, yes, LLMs are interesting, but not necessarily that much of a game-changer when compared to the mess we are already in.

bgwalter 1y ago

How many bandwagons has this guy jumped on? Now he says that LLMs will be the new high level programming languages but also that he listens to colleagues and hasn't really tried them yet. I suppose he is aiming for a new book and speaker fees from the LLM industrial complex.

somewhereoutth 1y ago

> As we learn to use LLMs in our work, we have to figure out how to live with this non-determinism. This change is dramatic, and rather excites me. I'm sure I'll be sad at some things we'll lose, but there will also things we'll gain that few of us understand yet. This evolution in non-determinism is unprecedented in the history of our profession. The whole point of computers is that they were deterministic, such that any effective method can be automated - leaving humans to do the non-deterministic (and hopefully more fun) stuff. Why do we want to break this up-to-now hugely successful symbiosis?

stpedgwdgfhgdd 1y ago

I’m programming software development workflows for Claude in plain english (custom commands). The non-deterministic is indeed a (tiny!) bit of a problem, but just tell Claude to improve the command so next time it won’t make the same mistake. One time it added an implementation section to the command. Pretty cool This is the big game changer: we have a programming environment where the program can improve itself. That is something Fortran couldn’t do.

stpedgwdgfhgdd 1y ago
(bit off topic, but I wished someone told me this a few months ago; for regular programming generation, use TDD and a type safe language like Go. (Fast compile times and excellent testing support). Don’t aim for the magical huge waterfall prompt)

dingnuts 1y ago

If LLMs are the new compilers, enabling software to be built with natural language, why can't LLMs just generate bytecode directly? Why generate HLL code at all?

Uehreka 1y ago
Why would the ability to generate source code imply the ability to generate bytecode? Also you wouldn’t want that, humans can’t review bytecode. I think you may be taking the metaphor too literally.
- pixl97 1y ago
  I dont think they are... LLMs can learn from anything thats been tokenized. Feed enough decompiled and labeled data with the bytecode and it's likely the machine will be able to dump out an executable. I wouldn't be surprised if an llm could output a valid elf right now other than the tokens may have been stripped in pretraining.
  - bird0861 1y ago
    https://ai.meta.com/research/publications/meta-large-language-model-compiler-foundation-models-of-compiler-optimization/ https://ai.meta.com/research/publications/meta-large-languag...
- skydhash 1y ago
  Because the semantic for each term in a programming language is pretty much a 1:1 relation to a sequential and logic-based ordering of terms in bytecode (which are still code). > Also you wouldn’t want that, humans can’t review bytecode The one great thing about automation (and formalism) is that you don't have to continuously review it. You vet it once, then you add another mechanism that monitors for wrong output/behavior. And now, the human is free for something else.
VinLucero 1y ago
I agree here. English (human language) to Bytecode is the future. With reverse translation as needed.

ptx 1y ago

> As we learn to use LLMs in our work, we have to figure out how to live with this non-determinism [...] but there will also things we'll gain that few of us understand yet. No thanks. Let's not give up determinism for vague promises of benefits "few of us understand yet".

aradox66 1y ago
Determinism isn't always ideal. Determinism may trade off with things like accuracy, performance, etc. There are situations where the tradeoff is well worth it.
- pixl97 1y ago
  Yep, there are plenty of things that aren't computable without burning all the entropy in the visible universe, yet if you exchange it with a heuristic you can get a good enough answer in polynomial time. Weather forecasts are a good example of this.
  - josefx 1y ago
    Most heuristics are still deterministic.
  - betenoire 1y ago
    I understand there are probabilities and shortcuts in weather forecasts.... but what part is non-deterministic?
- aradox66 1y ago
  Also, at temperature 0 LLMs can behave deterministically! Indeterminism isn't necessarily quite the right word for the kind of abstraction LLMs provide
  - josefx 1y ago
    That runs into the issue that nobody runs LLMs with a temperature of zero.

sgt101 1y ago

LLMs are deterministic. If you run an LLM with optimization turned on on a NVIDIA GPU then you can get non-deterministic results. But, this is a choice.

bwfan123 1y ago

Can authors of such articles at least cite Dijkstra's "On the foolishness of "natural language programming"." which appeared eons ago ? Which presents an argument against the "english is a programming language" hype. [1] https://www.cs.utexas.edu/~EWD/transcriptions/EWD06xx/EWD667.html https://www.cs.utexas.edu/~EWD/transcriptions/EWD06xx/EWD667...

awb 1y ago
Interesting read and thanks for sharing. Two observations: 1. Natural language appears to be to be the starting point of any endeavor. 2. > It may be illuminating to try to imagine what would have happened if, right from the start our native tongue would have been the only vehicle for the input into and the output from our information processing equipment. My considered guess is that history would, in a sense, have repeated itself, and that computer science would consist mainly of the indeed black art how to bootstrap from there to a sufficiently well-defined formal system. We would need all the intellect in the world to get the interface narrow enough to be usable, and, in view of the history of mankind, it may not be overly pessimistic to guess that to do the job well enough would require again a few thousand years. LLMs are trying to replicate all of the intellect in the world. I’m curious if the author would consider that these lofty caveats may be more plausible today than they were when the text was written.
- bwfan123 1y ago
  > I’m curious if the author would consider that these lofty caveats may be more plausible today than they were when the text was written. What is missed by many and highlighted in the article is the following: that there is no way to be "precise" with natural languages. The "operational definition" of precision involves formalism. For example, I could describe to you in english how an algorithm works, and maybe you understand it. But for you to precisely run that algorithm requires some formal definition of a machine model and steps involved to program it. The machine model for english is undefined ! and this could be considered a feature and not a bug. ie, It allows a rich world of human meaning to be communicated. Whereas, formalism limits what can be done and communicated in that framework.

w10-1 1y ago

> I've not had the opportunity to do more than dabble with the best Gen-AI tools, but I'm fascinated as I listen to friends and colleagues share their experiences. I'm convinced that this is another fundamental change So: impressions of impressions is the foundation for a declaration of fundamental change? What exactly is this abstraction? why nature? why new? RESULT: unfounded, ill-formed expression

agentultra 1y ago

Abstraction? Hardly. What are the new semantics and how are the lower levels precisely implemented? Spoken language isn’t precise enough for programming. I’m starting to suspect what people are excited about is the automation.

skydhash 1y ago
But that's not really automation. It's more search and act based on the first output. You don't know what's going to come out, you just hope it will be good. The issue is that that the query is fed to the output function. So what you get is a mixture of what is a mixture of what you told it and what's was stored. Great if you can separate the two afterwards, not so if the output is tainted by the query. With automation, what you seek is predictability. Not an echo chamber. ADDENDUM If we continue with the echo chamber analogy: Prompt Engineering: Altering your voice so that the result back is more pleasant System Prompt: The echo chamber's builders altering the configuration to get the above effects RAG: Sound effects Agent: Replace yourself in front of the echo chamber with someone/something that act based on the echo.

abeppu 1y ago

I think we should shift the focus from adapting LLMs to our purposes (e.g. external tool use) and adapting how we think about software and focus on getting models that internally understand compilation and execution. Rather than merely building around next token prediction, the industry should take advantage of the fact that software in particular provides a cheap path to learning a domain-specific "world model". Currently I sometimes get predictions where a variable that doesn't exist gets used or a method call doesn't match the signature. The text of the code might look pretty plausible but it's only relatively late that a tool invocation flags that something is wrong. If instead of just code text, we trained a model on (code text,IR, bytecode) tuples, (byte code, fuzzer inputs, execution trace) examples, and (trace, natural language description) annotations. The model needs to understand not just what token sequences seem likely but (a) what will the code compile to? (b) what does the code _do_ and (c) how would a human describe this behavior? Bonus points for some path to tie in pre/post conditions, invariants, etc "People need to adapt to weaker abstractions in the LLM era" is a short term coping strategy. Making models that can reason about abstractions in a much tighter loop and higher fidelity loop may get us code generation we can trust.

yuvadam 1y ago
These types of errors are not only rare in one-shots, but also very easy to fix in subsequent iterations - e.g. Claude Code with Sonnet rarely makes these errors.

perching_aix 1y ago

> so I can't just store my prompts in git and know that I'll get the same behavior each time. Yes you can, albeit it's pretty silly to do so. LLMs are not (inherently) nondeterministic, you're just not pinning the seed, or are using a remote, managed service for them with no reliability and consistency guarantees. [0] Here, experiment with me [1]: - download Ollama 0.9.3 (current latest) - download the model gemma3n e4b (digest: 15cb39fd9394) using the command "ollama run gemma3n:e4b" - pin the seed to some constant; let's use 42 as an example, by issuing the following command in the ollama interactive session started in the previous step: "/set parameter seed 42" - prompt the model: "were the original macs really exactly 9 inch?" It will respond with: > You're right to question that! The original Macintosh (released in 1984) *was not exactly 9 inches*. It was marketed as having a *9-inch CRT display*, but the actual usable screen size was a bit smaller. (...) Full response here: https://pastebin.com/PvFc4yH7 https://pastebin.com/PvFc4yH7 The response should be the same over time, across all devices, regardless of whether GPU-acceleration is available. Bit of an aside, but the overall sentiment echoed in the article reminds me to how visual programming was going to revolutionize everything and take programmers' jobs. With the exception that AI I find actually useful, and was able to integrate it into my workflow. [0] All of this is to say, to the extent LLM nondeterminism is currently a model trait, it is substituted using a PRNG. Actual nondeterminism is at most an inference engine trait typically instead, see e.g. batched inference. [1] Details are for experiment reproduction purposes. You can substitute the listed inference engine, model, seed, and prompt with whatever your prefer for your own set of experiments.

0points 1y ago
It's only deterministic with that exact model and that exact seed. So you are SOL unless you have a copy of that model.
- perching_aix 1y ago
  And that exact prompt and that exact inference engine [version]. Pretty reasonable if you ask me. All of this was to say, these are still programs, all the regular sensibilities still apply. Heck, even for that, the sensibilities that apply are pretty old-school: in modern, threaded applications, you'd expect runtime behavioral variations. Not the case here. Even for the high-level language compilers referred to in the article, this doesn't apply so easily. The folks over at reproducible builds [0] put in a decent bit of effort to my knowledge to make it happen. The overarching point being that it's not magic: it's technology. And if you hold them to even broadly similar standards you hold compilers to, they are absolutely deterministic. In case you mean that if you pick anything else other than what I picked here, the process ceases to be deterministic, that is not true. You can trivially test and confirm that the same way I did. [0] https://reproducible-builds.org/ https://reproducible-builds.org/

gdubs 1y ago

The Star Trek computer – I grew up with TNG – is the example I always think of. They ask it in human language to pull up some data, create a visualization, run an analysis. You get the sense that people also still write programs in the future in a more manual way – but, done well these LLMs are the building blocks for that more conversational way of getting the computer to do what you want it to do. A lot of the complaints that come up on Hacker News are around the idea that a piece of code needs to be elegantly crafted "Just so" for a particular purpose. An efficient algorithm, a perfectly correct program. (Which, sorry but – have you seen most of the software in the world?) And that's all well and good – I like the craft too. I'm proud of some very elegant code I've written. But, the writing is on the wall – this is another turning point in computing similar to the personal computer. People scoffed at that too. "Why would regular people want a computer? Their programs will be awful!"

UltraSane 1y ago

a TLA+ model combined with a good LLM to generate code from it is the ultimate level of useful abstraction.

mrheosuper 1y ago

i have a "server" at home that host proxmox. On it there is 1 VM i used to test non-so-legal software, with no connection to internet or local network of course (hopefully proxmox virtual switch is good). I could say it's a lab, right ?

rkhalaf 1y ago

Now that machines can also follow natural language instructions, then programs can become a mix of code and natural language - using each where it makes the most sense. We looked into how we could blend this by integrating natural language within a programming system here https://blog.ballerina.io/posts/2025-04-26-introducing-natural-programming/ https://blog.ballerina.io/posts/2025-04-26-introducing-natur... and @bwfan123, we did cite Dijkstra as well as Knuth. I believe sometimes you need the rigor of symbolic notation and other times you need the ambiguity of language - it depends on what you are doing and we can let the user decide how and when to blend the two. It's not about one or the other, but a gentle and harmonious blending