10 ms·
Dijkstra On the foolishness of "natural language programming"
- 0x1ceb00da 1y agoWhen was it written? The date says 2010 but dijkstra died in 2002.
- SirHumphrey 1y agoIt’s just a date of transcription. The letter was written in 1978.
- jruohonen 1y agoA great find! The whole thing seems a step (or several steps) backwards also in terms of UX. I mean surely there was a reason why ls was named ls, and so forth? A bonus point is that he had also something to say about a real or alleged degeneration of natural languages themselves.
- chilldsgn 1y agoThis is the most beautiful thing I've read in a long time.
- gitanovic 1y agoMe too, I printed it and underlined it, I will try to memorize some of the concepts and the exposition, because this is a cristallization of what I vaguely feel about the abuse of LLM I am currently witnessing
- chilldsgn 1y agoAbsolutely with you on the abuse of LLMs. I'm deeply concerned about loss of competence and I am so burned out from having to deal with other people's messy and overly complex code. I think people who think about this like us need to start building resilience for the very real possibility that in a couple of years we'll be the ones dealing with these awful LLM-generated code bases, fixing bad logic and bugs.
- misja111 1y agoI somewhat disagree with this. In real life, say in some company, the inception of an idea for a new feature is made in the head of some business person. This person will not speak any formal language. So however you turn it, some translation from natural language to machine language will have to be done to implement the feature. Typically the first step, translation from natural to formal language, will be done by business analysts and programmers. But why not try to let computers help along the way?
- chilldsgn 1y agoI like your take. The only issue I have with trusting a computer to do so much is that it doesn't necessarily have the long term vision or intuition some humans might have for the direction of the software product. There's so much nuance to the connection between a business need and getting it into software, or maybe I am overthinking it :D
- delusional 1y agoI don't think youre fully comprehending Dijkstra's argument. He's not saying to not use tool to help with translation, he is saying that not thinking in terms of formal symbols HURTS THINKING. Your ideas are worse if you don't think in formal systems. If you don't treat your thoughts as formal things. In your example, he has no opinion on how to translate the idea of a "business person" because in his view the ideas of the "business person" are already shallow and bad because they don't follow a formalism. They are not worth translating.
- robertlagrant 1y agoIf that's correct, then it's very falsifiable. If a businessperson says "there's a gap in the market - let's build X" they will be following a formalism at their level of detail. They see the market, the interactions between existing products and customers, and where things might be going. Just because they can't spell it out to the nth degree doesn't matter. Their formalism is "this is what the market would like". Having an LLM then tease out details - "what should happen in this case" would actually be pretty useful.
- hamstergene 1y agoReminds me of another recurring idea of replacing code with flowcharts. First I've seen that idea coming from some unknown Soviet professor from 80s, and then again and again from different people from different countries in different contexts. Every time it is sold as a total breakthrough in simplicity and also every time it proves to be a bloat of complexity and a productivity killer instead. Or weak typing. How many languages thought that simplifying strings and integers and other types into "scalar", and making any operation between any operands meaningful, would simplify the language? Yet every single one ended up becoming a total mess instead. Or constraint-based UI layout. Looks so simple, so intuitive on simple examples, yet totally failing to scale to even a dozen of basic controls. Yet the idea keeps reappearing from time to time. Or an attempt at dependency management by making some form of symlink to another repository e.g. git modules, or CMake's FetchContent/ExternalProject? Yeah, good luck scaling that. Maybe software engineering should have some sort of "Hall of Ideas That Definitely Don't Work", so that young people entering the field could save their time on implementing one more incarnation of an already known not good idea.
- d1sxeyes 1y agoNot sure if you’re talking about DRAKON here, but I love it for documentation of process flows. It doesn’t really get complicated, but you can very quickly end up with drawings with very high square footage. As a tool for planning, it’s not ideal, because “big-picture” is hard to see. As a user following a DRAKON chart though, it’s very, very simple and usable. Link for the uninitiated: https://en.m.wikipedia.org/wiki/DRAKON https://en.m.wikipedia.org/wiki/DRAKON
- octacat 1y agoMost popular dependency management systems literally linking to a git sha commit (tag), see locks file that npm/rebar/other tool gives you. Just in a recursive way.
- hamstergene 1y agoThey do way more than that. For example they won't allow you to have Foo-1 that depends on Qux-1 and Bar-1 that depends on Qux-2 where Qux-1 and Qux-2 are incompatible and can't be mixed within the same static library or assembly. But may allow it if mixing static-private Qux inside dynamic Foo and Bar and the dependency manager is aware of that. A native submodule approach would fail at link time or runtime due to attempt to mix incompatible files in the same build run. Or, in some build systems, simply due to duplicate symbols. That "just in a recursive way" addition hides a lot of important design decisions that separate having dependency manager vs. not having any.
- Animats 1y ago(2010) This refers to the era of COBOL, or maybe Hypertalk, not LLMs.
- guy234 1y agoThe original text was from 1978 according to other sources
- Animats 1y agoRight, it seemed earlier.
- bambax 1y agoAh, thanks. Yes it couldn't have been 2010 because he died in 2002. But the date this was written is important, otherwise his references to "the last decade" don't mean anything!
- yaris 1y agoMany would say that "the last decade" (with the surrounding context) is timeless, or at least that it is still relevant today.
- imglorp 1y agoApple didn't learn those lessons with Apple Script either: there is a rigid sequence of characters that represents a valid program and if you're off by one character, tough. If you're lucky, the tool will guide you to what it wants. If not, you're stuck looking up the exact syntax so off to the reference manual you go, either way. So there's minimal to looking up the syntax, whether it's based on some natural language phrase or a less wordy or ambiguous artificial language. "friendly" or "natural" really is not a thing.
- octacat 1y agoNatural language is pretty good for describing the technical requirements for the complex system, though. I.e. not the current code implementation, but why the current code implementation is selected vs other possible implementations. Not what code do, but what it is expected to do. Basically, most of the missing parts, that live in Jira-s, instead of your repo. It is also good, at allowing better refactoring capabilities, when all your system is described by outside rules, which could be enforced on the whole codebase. We just use programming languages, because it is easier to use in automated/computer context (and was the only way to use, to be honest, before all the LLM stuff). Though, while it gives us non-ambiguity on the local scale, it stops working on the global scale, the first moment person went and copy-pasted part of the code. Are you sure that part follows all the high-level restrictions we should to follow and is correct program? It is program that would run, when compile, but definition of run is pretty loose. In C++ program that corrupts all the memory is also runnable.
- grahamlee 1y agoDijkstra also advocated for proving the correctness of imperative code using the composition of a set of simple rules, and most programmers ignore that aspect of his work too.
- yapyap 1y ago(2010) by the way, which makes this article all the more impressive. I was under the assumption this was a current body of work seeing as Dijkstra spoke so well about the possibilities but this just goes to show some people were ahead of their tike with their worries. Also adding your home address to something you write / publish / host on the internet is pretty hardcore.
- dr_dshiv 1y agoHe didn’t understand the concept of the vibe. Here’s the best theory article I’ve read https://www.glass-bead.org/article/a-theory-of-vibe/ https://www.glass-bead.org/article/a-theory-of-vibe/
- serallak 1y agoThe difference between the clarity of Dijkstra writing and the text at this link is astounding.
- dr_dshiv 1y agoVibes aren’t really about clarity, are they? The point is that a clear, programmatic approach is not the only effective computational mechanism for realizing intentions anymore. Keep in mind that Dijkstra had some giant shoulders to stand on. This article is the very first one I’ve ever seen that directly dealt with vibes.
- WillAdams 1y agoThe thing is, for at least some readers, the attraction of _The Glass Bead Game_ and similar abstractions is that they should be able to communicate more clearly, and without the ambiguity of natural language, but with a naturalness which allows unbridled expression. I really would like to see such a programming system realized, see efforts at: https://github.com/IndieSmiths/myappmaker-sdd https://github.com/IndieSmiths/myappmaker-sdd but the more I work at programming, the more the solution seems to be documentation, and the best system for documenting code and the information about it seems to be: http://literateprogramming.com/ http://literateprogramming.com/ I just need to find the perfect GUI toolkit which allows Bézier Curve representations in a way which clicks and makes sense to me, and suits my next project.
- skydhash 1y ago> I just need to find the perfect GUI toolkit which allows Bézier Curve representations in a way which clicks and makes sense to me, and suits my next project. Not a proper answer, but here is a very good video on splines: https://youtu.be/jvPPXbo87ds https://youtu.be/jvPPXbo87ds
- fedeb95 1y agothis clearly has nothing to do with the current main usages of LLMs, it's about using natural language as an interface to produce accurate results, as a further abstraction on top of general purpose languages.
- recursive 1y agoWhat is the difference between those things?
- fedeb95 1y agoLLMs take natural language as input and produces it as output (note that producing source code is the same thing). The algorithm that takes input and produces output is still written in mathematical precise symbols and needs to be accurate, even if the input and output aren't expressed in a formal language. We will see if and when an algorithm can be parsed and executed from a natural language "source code" and if that is an improvement. Also note that "source code" implies it is a code. Natural languages are not a code, that is, a unique mapping from a set to another.
- 01100011 1y agoPeople are sticking up for LLMs here and that's cool. I wonder, what if you did the opposite? Take a project of moderate complexity and convert it from code back to natural language using your favorite LLM. Does it provide you with a reasonable description of the behavior and requirements encoded in the source code without losing enough detail to recreate the program? Do you find the resulting natural language description is easier to reason about? I think there's a reason most of the vibe-coded applications we see people demonstrate are rather simple. There is a level of complexity and precision that is hard to manage. Sure, you can define it in plain english, but is the resulting description extensible, understandable, or more descriptive than a precise language? I think there is a reason why legalese is not plain English, and it goes beyond mere gatekeeping.
- Affric 1y agoSure but we build (leaky) abstractions, and this is even happens in legal texts. Asking an llm to build a graphical app in assembly from an ISA and a driver for the display would give you nothing. But with a mountain of abstractions then it can probably do it. This is not to defend an LLM more to say I think that by providing the right abstractions (reusable components) then I do think it will get you a lot closer.
- fsloth 1y agoBeing doing toy-examples of non-trivial complexity. Architecting the code so context is obvious and there are clear breadcrumbs everywhere is the key. And the LLM can do most of this. Prototype-> refactor/cleanup -> more features -> refactor / cleanup add architectural notes. If you know what a well architected piece of code is supposed to look like, and you proceed in steps, LLM gets quite far as long as you are handholding it. So this is usable for non-trivial _familiar_ code where typing it all would be slower than prompting the llm. Maintaining LLM context is the key here imo and stopping it when you see weird stuff. So it requires you act as thr senior partner PR:ing everyhting.
- cdkmoose 1y ago
- jumploops 1y ago> I suspect that machines to be programmed in our native tongues —be it Dutch, English, American, French, German, or Swahili— are as damned difficult to make as they would be to use. Seeing as transformers are relatively simple to implement… It stands to reason he was, in some sense, right. LLMs are damn easy to use.
- recursive 1y agoUnless you include "getting correct results" within the scope of "use".
- karmasimida 1y agoWho is laughing now? It is clear NLU can't be done in the reign of PL itself, there is never going to be natural language grammar that is precise as PL. But LLM is a different kind of beast entirely.
- Rodmine 1y agoWhat needs to be done can and is almost always described in natural language. Whether that is feasible is a different question (https://xkcd.com/1425/ https://xkcd.com/1425/), but also can be described in natural language. Here is something I tried with o3-mini: > Create a program that takes an input image and can tell if there is a bird in it. > ChatGPT said: > Reasoned for 38 seconds > Below is an example in Python that uses TensorFlow’s Keras API and a pre-trained ResNet50 model to classify an input image. The code loads an image, preprocesses it to the required size, obtains the top predictions, and then checks if any of the top labels appear to be a bird. You can expand the list of bird keywords as needed for your application. > python code that works If you take the critical view, you can always find a way to find an exception that will fail. I can see many happy cases which will just work most of the time, even with the currently available technology. Most of the programming work done today is putting libraries and api services together.
- James_K 1y agoIt's pretty obvious to me that this LLM business won't be economically feasible until it can actually produce better code than a team of humans could without it. The reason programmers are paid so highly is because their work is incredibly productive and valuable. One programmer can enable and improve the work of many hundreds of other people. Cost cutting on the programmer isn't worth it because it'll create greater losses in other places. Hence the high salaries. Every saving you make on the programmer is magnified a hundred times in losses elsewhere.
- metalliqaz 1y agogiven that LLMs are going to produce code that is essentially an average of the code it has been trained on, which is all human code of varying quality, I don't see how the current methods are going to actually produce better code than humans do when working with their own domain-specific knowledge.
- recursivedoubts 1y agolooks at https://hyperscript.org https://hyperscript.org laughs nervously
- Dansvidania 1y ago- some people found error messages they couldn't ignore more annoying than wrong results I wonder if this is a static vs dynamic or compiled vs interpreted reference. Anyway I love it. Made me giggle that we are still discussing this today, and just to be clear I love both sides, for different things.
- arkh 1y ago50 years ago, in "The Mythical Man-Month" Fred Brooks was already discussing the cost of cloud based solutions. > Since size is such a large part of the user cost of a programming system product, the builder must set size targets, control size, and devise size-reduction techniques, just as the hardware builder sets component-count targets, controls component count, and devises count-reduction techniques. Like any cost, size itself is not bad, but unnecessary size is. And the why of Agile, DDD and TDD: > Plan the System for Change [...] Plan the Organization for Change
- nsonha 1y agoIs this necessarily a stance against LLM? LLMs can generate real code, ideally functional, strict code instead of the slop they do these days.
- l0new0lf-G 1y agoFinally someone put it this way! Natural language has embedded limitations that stem from our own mental limitations -the human mind thinks sometimes too abstract or too specific things, and misses important details or generalizations. As a programmer, I know first hand that the problems or even absurdities of some assignments only become apparent after one has begun implement the code as code, i.e. as strict symbolisms. Not to mention that it often takes more time to explain something accurately in natural language than it takes to just write the algorithm as code.
- chilldsgn 1y agoYes! I have a certain personality preference for abstractions and tend to understand things in an abstract manner which is extremely difficult for me to articulate in natural language.
- roccomathijn 1y agoThe man has been dead for 23 years
- moralestapia 1y agoThis is one of the best comments I've read on this site in a long while. A single, crude, statement of fact slaying the work of a million typewriter monkeys spewing out random characters thinking they're actually writing the Shakespeare novel, lmao.
- indigoabstract 1y agoHe's the Immortal Dutchman.
- pyrale 1y agoI wonder how long we have to wait before we can pitch a machine that presses fruit juice packs into a glass to gullible VCs again.
- MattSayar 1y agoWe need realistic expectations for the limitations of LLMs as they work today. Philosophically, natural language is imperfect at communicating ideas between people, which is its primary purpose! How often do you rewrite sentences, or say "actually what I meant was...", or rephrase your emails before pressing Send? We are humans and we rarely get things perfect on the first try. And now we're converting this imperfect form of communication (natural language) into a language for machines (code), which notoriously do exactly what you say, not what you intend. NLP is massively, and I mean massively, beneficial to get you started on the right path to writing an app/script/etc. But at the end of the day it may be necessary to refactor things here and there. The nice thing is you don't have to be a code ninja to get value out of LLMs, but it's still helpful and sometimes necessary.
- haolez 1y agoThis reminded me of this old quote from Hal Abelson: "Underlying our approach to this subject is our conviction that "computer science" is not a science and that its significance has little to do with computers. The computer revolution is a revolution in the way we think and in the way we express what we think. The essence of this change is the emergence of what might best be called procedural epistemology—the study of the structure of knowledge from an imperative point of view, as opposed to the more declarative point of view taken by classical mathematical subjects. Mathematics provides a framework for dealing precisely with notions of "what is". Computation provides a framework for dealing precisely with notions of "how to"."
- Cheer2171 1y agoWell that sure isn't what they teach in computer science programs anymore
- light_triad 1y agoThis is key: computation is about making things happen. Coding with an LLM adds a level of abstraction but the need for precision and correctness of the "things that happen" doesn't go away. No matter how many cool demos and "coding is dead" pronouncements because AI - and the demos are very cool - the bulk of the work moves to the pre- and post-processing and evals with AI. To the extent that it makes programming more accessible it's a good thing, but can't really replace it.
- rootnod3 1y agoYeah but in the end when it comes down to it, one would have to specify the exact details, especially for very intricate systems. And the more and more you would abstract and specialize that language for the LLM, you end up going a very long round about way to re-inventing code basically.
- pyrale 1y agoHal Abelson, casually enraging functional programing CS people around the world.
- jedimastert 1y ago> It was a significant improvement that now many a silly mistake did result in an error message instead of in an erroneous answer. (And even this improvement wasn't universally appreciated: some people found error messages they couldn't ignore more annoying than wrong results, and, when judging the relative merits of programming languages, some still seem to equate "the ease of programming" with the ease of making undetected mistakes.) If I didn't know who wrote this it would seem like a jab directly at people who dislike Rust.
- still_grokking 1y agoRust? Since when is Rust the pinnacle of static type safety? After I've worked for some time with a language that can express even stronger invariants in types than Rust (Scala) I don't see that property anymore as clear win regardless circumstances. I don't think any more "stronger types == better, no matter what". You have a price to pay for "not being allowed to do mistakes": Explorative work becomes quite difficult if the type system is really rigid. Fast iteration may become impossible. (Small changes may require to re-architecture half your program, just to make the type system happy again![1]) It's a trade-off. Like with everything else. For a robust end product it's a good thing. For fast experimentation it's a hindrance. [1] Someone described that issue quite well in the context of Rust and game development here: https://loglog.games/blog/leaving-rust-gamedev/ https://loglog.games/blog/leaving-rust-gamedev/ But it's not exclusive to Rust, nor game dev.
- mjburgess 1y agoI can't remember if I came up with this analogy or not, but programming in Rust is like trying to shape a piece of clay just as it's being baked.
- card_zero 1y ago> Explorative work becomes quite difficult if the type system is really rigid Or to put it another way, the ease of programming is correlated with the ease of making undetected mistakes.
- jedimastert 1y agoOver the last couple of weeks or so of me finally starting to use AI pair programming tools (for me, Cursor) I've been realizing that, much like when I play music, I don't really think about programming a natural language terms in the first place, it's actually been kind of hard to integrate an AI coding agent into my workflow mentally
- odyssey7 1y agoThis is also, inadvertently, an argument against managers. Why talk to your team when you could just program it yourself?
- wiz21c 1y ago> Remark. As a result of the educational trend away from intellectual discipline, the last decades have shown in the Western world a sharp decline of people's mastery of their own language: many people that by the standards of a previous generation should know better, are no longer able to use their native tongue effectively, even for purposes for which it is pretty adequate. Compare that to: https://news.ycombinator.com/item?id=43522966 https://news.ycombinator.com/item?id=43522966
- indigoabstract 1y agoUsing natural language to specify and build an application is not unlike having a game design document before you actually start prototyping your game. But once you have implemented the bulk of what you wanted, the implementation becomes the reference and you usually end up throwing away the GDD since it's now out of sync with the actual game. Insisting that for every change one should go read the GDD, implement the feature and then sync back the GDD is cumbersome and doesn't work well in practice. I've never seen that happen. But if there ever comes a time when some AI/LLM can code the next version of Linux or Windows from scratch based on some series of prompts, then all bets are off. Right now it's clearly not there yet, if ever.
- cafard 1y agoSo many Dijkstra links amount to "Dijkstra on the [pejorative noun] of [whatever was bothering Dijkstra]." I promise to upvote the next Dijkstra link that I see that does not present him as Ambrose Bierce with a computer.
- sitkack 1y agoDijkstra is actually a time traveling Brian Rantrill
- still_grokking 1y agoBy chance I came just today across GitHub's SpecLang: https://githubnext.com/projects/speclang/ https://githubnext.com/projects/speclang/ Funny coincidence! I leave it here for the nice contrast it creates in light of the submission we're discussing.
- nyeah 1y agoBut Dijkstra was writing long ago. I'm sure the situation is greatly improved today.
- ma9o 1y agoPeople are supposed to communicate symbolically with LLMs too
- sotix 1y ago> Machine code, with its absence of almost any form of redundancy, was soon identified as a needlessly risky interface between man and machine. Partly in response to this recognition so-called "high-level programming languages" were developed, and, as time went by, we learned to a certain extent how to enhance the protection against silly mistakes. It was a significant improvement that now many a silly mistake did result in an error message instead of in an erroneous answer. I feel that we’ve collectively jumped into programming with LLMs too quickly. I really liked how Rust has iterated on pointing out “silly mistakes” and made it much more clear what the fix should be. That’s a much more favorable development for me as a developer. I still have the context and understanding of the code I work on while the compiler points out obvious errors and their fixes. Using an LLM feels like a game of semi-intelligent guessing on the other hand. Rust’s compiler is the master teaching the apprentice. LLMs are the confident graduate correcting the master. I greatly prefer Rust’s approach and would like to see it evolved further if possible.
- astrobe_ 1y agoRust (and others) has type inference, LLMs have so-called "reasoning". They fake understanding, a lie that will sooner or later have consequences.
- nizarmah 1y agoOne of the most challenging aspects in my career has been: communication. This is largely because it leaves chance for misinterpretation or miscommunication. Programming languages eliminated misinterpretation and made miscommunication easier to notice through errors. Programming language enables micromanaging proactively, I specify the instructions before they run. I often find myself micromanaging retroactively with LLMs, until I reach the path I am looking for.
- yagyu 1y agoIn the same vein, Asimov in 1956: Baley shrugged. He would never teach himself to avoid asking useless questions. The robots knew. Period. It occurred to him that, to handle robots with true efficiency, one must needs be expert, a sort of roboticist. How well did the average Solarian do, he wondered?
- auggierose 1y agoFormal can be foolish, too. If you don't believe that, then I have a set for sale, with the property that it contains all sets that don't contain itself.
- throwaway587468 1y agoThe problem you’re referring to arose precisely due to lack of formalism. It was a problem back when mathematicians were toying with naive set theory, one not based on axioms, but instead on intuitive terminology. Moving to axiomatic, more formal, set theory solved it.
- auggierose 1y agoThe problem is the same, no matter if you look at it formally or informally. You could get your set theory axioms wrong, for example, but you would still be formal. Oh wait, you have a proof that set theory is consistent, right?
- Someone 1y ago/s: that’s because we haven’t gone far enough. People use natural language to generate computer programs. Instead, they should directly run prompts. “You are the graphics system, an entity that manages what is on the screen. You can receive requests from all programs to create and destroys “windows”, and further requests to draw text, lines, circles, etc. in a window created earlier. Items can be of any colour. You also should send more click information to whomever created the window in which the user clicked the mouse. There is one special program, the window manager, that can tell you what windows are displayed where on any of the monitors attached to the system” and “you are a tic-tac-toe program. There is a graphics system, an entity that manages what is on the screen. You can command it to create and destroys “windows”, and to draw text, lines, circles, etc. in a window created earlier. Items can be of any colour. The graphics you draw should show a tic-tac-toe game, where users take turn by clicking the mouse. If a user wins the game, it should… Add ads to the game, unless the user has a pay-per-click subscription” That should be sufficient to get a game running… To save it, you’d need another prompt: ”you are a file system, an entity that persists data to disk…” You also will want ”you are a multi-tasking OS. You give multiple LLMs the idea that they have full control over a system’s CPU and memory. You…” I look forward to seeing this next year in early April.
- slt2021 1y agoall these prompts are currently implemented under the hood by generating and running python code
- truculent 1y agoAny sufficiently advanced method of programming will start to look less like natural language and more like a programming language. If you still don’t want to do programming, then you need some way to instruct or direct the intelligence that _will_ do the programming. And any sufficiently advanced method of instruction will look less like natural language, and more like an education.
- musesum 1y agoPersonal context is tacit experience. Cultural context is aggregate. Wittgenstein stated that the differences between personal and cultural language makes it impossible to agree on anything foundational to philosophy. Godel did something similar to discrete structures by hacking self reference -- a kind of recursive self reference with no exit state. I think pair programming with an LLM is interesting. You get to compare personal context with aggregate context. Plus, the external feedback helps me break out of excessive personal self reference.
- card_zero 1y agoHeh, Popper wrote an entire book that says pretty much the opposite, but Wittgenstein attacked him with a poker once so maybe it was payback.
- alexvitkov 1y agoComputers do what you tell them to, not what you want them to. This is naturally infuriating, as when a computer doesn't do what you want, it means you've failed to express your vague idea in concrete terms. LLMs in the most general case do neither what you tell them, nor what you want them to. This, surprisingly, can be less infuriating, as now it feels like you have another actor to blame - even though an LLM is still mostly deterministic, and you can get a pretty good idea of what quality of response you can expect for a given prompt.
- atomicnature 1y agoLLMs are usually used to describe goals or to provide feedback (correction or encouragement) towards its implementation. Programming is about iteratively expressing a path towards satisfying said goals. What LLMs are doing now is converting "requirements" into "formalizations". I don't think Djikstra is wrong in saying - that performing programming in plain-language is a pretty weird idea. We want to concretize ideas in formalisms. But that's not what any human (including Djikstra) starts with... you start with some sort of goal, some sort of need and requirements. LLMs merely reduce the time/effort required to go from goals -> formalism. TLDR: Requirements != Implementation
- teleforce 1y ago> thanks to the carefully, or at least consciously designed formal symbolisms that we owe to people like Vieta, Descartes, Leibniz, and (later) Boole. Please check this talk on the contributions of these mentioned people for the complementary form of deterministic AI (machine intelligence) namely logic, optimization and constraint programming in a seminal lecture by John Hooker [1]. I have got the feeling that if we combine the stochastic nature of LLM based NLP with the deterministic nature of feature structure trchnique based NLP (e.g. CUE), guided by logic, optimization and constraint programming we probably can solve intuitive automation or at least perform proper automation (or automatic computing as Dijkstra put it). Apparently Yann LeCun also recently proposing optimization based AI namely inference through optimization, or objective driven AI in addition to data-driven AI [2]. Fun facts, you can see Donald Knuth asking questions towards the end of the JH's lecture presentation. [1] Logic, Optimization, and Constraint Programming: A Fruitful Collaboration - John Hooker - CMU (2023) [video]: https://www.youtube.com/live/TknN8fCQvRk https://www.youtube.com/live/TknN8fCQvRk [2] Mathematical Obstacles on the Way to Human-Level AI - Yann LeCun - Meta - AMS Josiah Willard Gibbs Lecture at the 2025 Joint Mathematics Meetings (2025) [video]: https://youtu.be/ETZfkkv6V7Y https://youtu.be/ETZfkkv6V7Y
- weeeee2 1y agoForth, PostScript and Assembly are the "natural" programming languages from the perspective of how what you express maps to the environment in which the code executes. The question is "natural" to whom, the humans or the computers? AI does not make human language natural to computers. Left to their own devices, AIs would invent languages that are natural with respect to their deep learning architectures, which is their environment. There is always going to be an impedance mismatch across species (humans and AIs) and we can't hide it by forcing the AIs to default to human language.
- cpuguy83 1y agoOne of the things LLM's/natural language programming brings is greater access. While the actual code may be crap, it opens up things to more people to play around and iterate on ideas without having to have a ton of knowledge. That is powerful by itself.
- HarHarVeryFunny 1y agoSeeing as much of the discussion here is about LLMs, not just the shortcomings of natural language as a programming language, another LLM-specific aspect is how the LLM is interpreting the natural language instructions it is being given... One might naively think that the "AI" (LLM) is going to apply it's intelligence to give you the "best" code in response to your request, and in a way it is, but this is "LLM best" not "human best" - the LLM is trying "guess what's expected" (i.e. minimize prediction error), not give you the best quality code/design per your request. This is similar to having an LLM play chess - it is not trying to play what it thinks is the strongest move, but rather trying to predict a continuation of the game, given the context, which will be a poor move if it thinks the context indicates a poor player. With an RL-trained reasoning model, the LLM's behavior is slightly longer horizon - not just minimizing next token prediction errors, but also steering the output in a direction intended to match the type of reasoning seen during RL training. Again, this isn't the same as a human, applying their experience to achieve (predict!) a goal, but arguably more like cargo-cult reasoning - following observed patterns of reasoning in the training set, without the depth of understanding and intelligence to know if this is really applicable in the current context, nor with the ability to learn from it's mistakes when it is not. So, while natural language itself is of course too vague to program in, which is part of the reason that we use programming languages instead, it's totally adequate as a way to communicate requirements/etc to an expert human developer/analyst, but when communicating to an LLM instead of a person, one should expect the LLM to behave as an LLM, not as a human. It's a paperclip maximizer, not a human-level intelligence.
- hinkley 1y agoAbout every six to ten years I look in on the state of the art on making artificial human languages in which one cannot be misunderstood. If we ever invent a human language where laws can be laid out in a manner that the meaning is clear, then we will have opened a door on programming languages that are correct. I don’t know that a programmer will invent this first. We might, but it won’t look that natural.
- wewewedxfgdf 1y agoWe are AI 1.0 Just like Web 1.0 - when the best we could think of to do was shovel existing printed brochures onto web pages. In AI 1.0 we are simply shoveling existing programming languages into the LLM - in no way marrying programming and LLM - they exist as entirely different worlds. AI 2.0 will be programming languages - or language features - specifically designed for LLMs.
- llsf 1y agoNatural language is poor medium at communicating rules and orders. The current state of affair in US is a prime example. We are still debating what some laws and amendments mean. The meaning of words change over time, lack of historical context, etc. I would love natural language to operate machines, but I have been programming since mid 80's and the stubbornness of the computer languages (from BASIC, to go) strikes a good balance, and puts enough responsibility on the emitter to precisely express what he wants the machine to do.
- ur-whale 1y ago> The foolishness of "natural language programming" Wasn't that the actual motivation behind the development of SQL? IIRC, SQL was something that "even" business people could code in because it was closer to "natural language". When you see the monstrosity the motivation gave birth to, I think the "foolish" argument was well warranted at the time. Of course, in these days of LLM's, Dijkstra's argument isn't as clear cut (even if LLM's aren't there yet, they're getting much closer).
- RazorDev 1y ago[flagged]
- johnwatson11218 1y agoWhy did mathematicians invent new symbols? Imagine if all of algebra, calculus, linear algebra looked like those word problems from antiquity? Natural language is not good for describing systems, symbolic forms are more compressed and be considered a kind of technology in its own right.
- aubanel 1y agoDjikstra's clarity of expression and thoguht is indeed impressive. One nuance : he seems to completely equate ease of language with ability to do undetectable mistakes. I disagree: I know people whose language is extremely efficient at producing analogies that can shortcut for the listener many pages of painful mathematical proofs: for instance, convenu the emergence of complexity for many simple processes by a "swarming"
- godelski 1y ago> he seems to completely equate ease of language with ability to do undetectable mistakes. I do not believe this is his argument. He was making the point that there is a balance. You need to consider the context of the times, and remember that in this context a language like C is considered "high-level", not a language like Python. He later moves on to discuss formalism through mathematics (referencing Vieta, Descartes, Leibniz, and Boole), in how this symbolism is difficult to perform and many are adverse to it, but that through its birth we've been able to reap a lot of rewards. He precisely makes the claim that were we not to move to formal methods and instead maintain everyday language, we would still be stuck at the level of the Greeks. Actually in one season of An Opinionated History of Mathematics, the host (a mathematician) specifically discusses the transition in the Greeks and highlights how many flaws there were in this system. How the slow move to mathematical formalism actually enabled correctness. The point is that human language is much more vague. It has to be this way. But the formalism in symbolics (i.e. math) would similarly make a terrible language for computing. The benefit of the symbolic approach is the extreme precision, but it also means the language is extremely verbose. While in human languages we trade precision for speed and flexibility. To communicate what I have with a mathematical language would require several pages of text. Like he says, by approaching human language this shifts more responsibility to the machine.
- wpollock 1y agoI love reading literate-programming software! The problem is that very few programmers are as skilled at writing clearly as are Knuth and Dijkstra. I think I read somewhere that book publishers receive thousands of manuscripts for each one they publish. Likewise, few programmers can write prose worth reading.
- quantum_state 1y agoA language is invented for a domain for precision and clarity the natural language cannot provide … trying to do the opposite would certainly create more work
- voidhorse 1y agoDijkstra is entirely correct in this, and it's something I've been trying to urge people to recognize since the beginnings of this LLM wave. There is inherent value in using formal language to refine, analyze, and describe ideas. This is, after all, why mathematical symbolism has lasted in spite of the fact that all mathematicians are more than capable of talking about mathematical ideas in their natural tongues. Code realizes a computable model of the world. A computable model is made up of a subset of the mathematical functions we can define. We benefit greatly from formalism in this context. It helps us be precise about the actual relationships and invariants that hold within a system. Stable relationships and invariants lead to predictable behaviors, and predictable systems are reliable systems on the plan of human interaction. If you describe your system entirely in fuzzily conceived natural language, have you done the requisite analysis to establish the important relationships and invariants among components in your system, or are you just half-assing it? Engineering is all about establishing relative degrees of certainty in the face of the wild uncertainty that is the default modality of existence. Moving toward a world in which we "engineer" systems increasingly through informal natural language is a step backwards on the continuum of reliability, comprehensibility, and rigor. The fact that anyone considers using these tools and still thinks of themselves as an "engineer" of some kind is an absolute joke.
- centra_minded 1y agoModern programming already is very, very far from strict obedience and formal symbolism. Most programmers these days (myself included!) are using libraries, frameworks, and other features that mean what they are doing in practice is wielding sky-high abstractions, gluing things together they do not (and can not) fully understand the inner workings of. If I create a website with Node.js, I’m not manually managing memory, parsing HTTP requests byte-by-byte, or even attempting to fully grasp the event loop’s nuances. I’m orchestrating layers of code written by others, trusting that these black boxes will behave as advertised according to my best, but deeply incomplete, understanding of them. I'm not sure what this means for LLMs programming, but I already feel separated from the case Dijkstra lays out.
- tired-turtle 1y ago> Modern programming already is very, very far from strict obedience and formal symbolism Difficult to sort this out with what follows. Consider group theory. A group G is a set S with an operator * that supports an identity, closure, and an inverse. With that abstraction comes a hefty amount of power. In some sense, a group is akin to a trait on some type, much like how a class in Java can implement or extend Collection. (Consider how a ring ‘extends’ a group.) I’d posit frameworks and libraries are no different in terms of formal symbolism from the math structure laid out above. Maybe the interfaces are fuzzy and the documentation is shoddy, but there’s still a contract we use to reason about the tool at hand. > I’m not manually managing memory, parsing HTTP requests byte-by-byte If I don’t reprove Peano’s work, then I’m not really doing math?
- 0xbadcafebee 1y agoI read this when I was younger, but I only now get it, and realize how true it all is. 13) Humans writing code is an inherently flawed concept. Doesn't matter what form the code takes. Machine code, assembly language, C, Perl, or a ChatGPT prompt. It's all flawed in the same way. We have not yet invented a technology or mechanism which avoids it. And high level abstraction doesn't really help. It hides problems only to create new ones, and other problems simply never go away. 21) Loosely coupled interfaces made our lives easier because it forced us to compartmentalize our efforts into something manageable. But it's hard to prove that this is a better outcome overall, as it forces us to solve problems in ways that still lead to worse outcomes than if we had used a simpler [formal] logic. 34) We will probably end up pushing our technical abilities to the limit in order to design a superior system, only to find out in the end that simpler formal logic is what we needed all along. 55) We're becoming stupider and worse at using the tools we already have. We're already shit at using language just for communicating with each other. Assuming we could make better programs with it is nonsensical. For a long time now I've been upset at computer science's lack of innovation in the methods we use to solve problems. Programming is stupidly flawed. I've never been good at math, so I never really thought about it before, but math is really the answer to what I wish programming was: a formal system for solving a problem, and a formal system for proving that the solution is correct. That's what we're missing from software. That's where we should be headed.
- tempodox 1y agoThe voice of reason, but no amount of reason can dissuade anybody from believing what they want to believe.
- charlieyu1 1y agoNatural language is just never good enough for computing tasks. We should learn to speak logic languages instead