Live data from Hacker News

Solving the Wrong Problem

ufried.com

11–20 of 26 posts

Re: Solving the Wrong Problem

#11
> They respond in much smarter ways than traditional multi-layer perceptrons or traditional RNNs like LSTM networks because their attention mechanisms helps them to make much better sense of the input they were provided by selectively paying more or less attention to different parts of the input (including their output generated so far). This is similar to what humans do.

This is not in any way similar to what humans do.

Re: Solving the Wrong Problem

#12
post #2

Feel this strongly. That all of the "autocomplete"-style improvements that LLMs to programming are indications of massive deficiencies in programming: we're in many ways stuck in a ~2010-era model of what programming is, which is actually quite medieval and useless. Probably programs as "text that you run on a computer" is, long-term, not how anything is going to be done. After all, what is a prompt but a (lossy, err…

You might like this post I wrote: https://open.substack.com/pub/btmc/p/thoughts-on-visual-prog...

Re: Solving the Wrong Problem

#13

Suppose that an LLM would produce excellent, production-ready code automatically given high-quality architecture and design documentation and proper requirements. Could we offload the code generation to the machine and focus on producing architecture and design documentation? And would that provide meaningful improvements? I don't know the answer to that. But it's an interesting point that's buried in the article is…

I find the back and forth more productive. Lots of up front requirements and docs is like waterfall. You do everything up front and don't realize until implementation time that the design is unclear, has flaws and contradictions, etc.

Often it feels more efficient to take shorter steps, try something in code, we how it looks, update docs, show a demo, etc. That was true before LLMs and I think LLMs make it even more true.

Re: Solving the Wrong Problem

#14

Suppose that an LLM would produce excellent, production-ready code automatically given high-quality architecture and design documentation and proper requirements. Could we offload the code generation to the machine and focus on producing architecture and design documentation? And would that provide meaningful improvements? I don't know the answer to that. But it's an interesting point that's buried in the article is…

Nah, we’d still get architecture wrong.

Re: Solving the Wrong Problem

#15
post #5
post #2

Feel this strongly. That all of the "autocomplete"-style improvements that LLMs to programming are indications of massive deficiencies in programming: we're in many ways stuck in a ~2010-era model of what programming is, which is actually quite medieval and useless. Probably programs as "text that you run on a computer" is, long-term, not how anything is going to be done. After all, what is a prompt but a (lossy, err…

This is in some ways a circular argument / problem. Because, what does a well-specified formalisation of a problem solution look like? It looks like a programming language. Since COBOL, the dream has been a language which is formalised for computers while being understandable and able to be written by "business users". We've been promised this future by COBOL, Visual Basic, SQL, and many others. And what does the rea…

Agreed. Basically, open some random piece of code. Try explaining it in English with perfect precision. That's what "coding" in natural language would be like. Way more verbose, open to misinterpretation, harder for engineers to follow, still impenetrable to non-engineers, and with the added possibilities of hallucination at code generation time.

LLMs are great (sometimes) for conversational editing where there's a fast, iterative back and forth between description, code, clarification and touch-ups, etc. But trying to avoid code entirely eventually makes everything harder, not easier.

Re: Solving the Wrong Problem

#16
post #2

Feel this strongly. That all of the "autocomplete"-style improvements that LLMs to programming are indications of massive deficiencies in programming: we're in many ways stuck in a ~2010-era model of what programming is, which is actually quite medieval and useless. Probably programs as "text that you run on a computer" is, long-term, not how anything is going to be done. After all, what is a prompt but a (lossy, err…

Right. If an LLM is capable of writing good boilerplate code for you then your programming language is too low level. We need higher level languages which abstract away most of the repetitive patterns. What would a language look like where the code has much higher "entropy" but is still human readable and maintainable? Like could we design a language that combines all of the productivity advantages of APL / Lisp / Prolog but is still usable by average developers?

Re: Solving the Wrong Problem

#17
post #2

Feel this strongly. That all of the "autocomplete"-style improvements that LLMs to programming are indications of massive deficiencies in programming: we're in many ways stuck in a ~2010-era model of what programming is, which is actually quite medieval and useless. Probably programs as "text that you run on a computer" is, long-term, not how anything is going to be done. After all, what is a prompt but a (lossy, err…

> Can we formalize that abstraction such that the prompt is an exact specification, just, at a super high level?

... And you want a representation of that abstraction to persist on disk?

... But it shouldn't be "text"?

Why not?

And how will you communicate it? You want to prompt in lossy, error-prone, inexact text, and then trust that an opaque binary blob correctly represents the formalization of what you meant? Or go through feedback cycles of trying to correct it with more prompting, but without the ability to edit manually?

> but no amount of text-generation gets around the fact that maybe text generation is... not... what we should be doing, actually.

Well, sure. But that isn't a problem with text; it's a problem with boilerplate in our designs.

Re: Solving the Wrong Problem

#18
post #16
post #2

Feel this strongly. That all of the "autocomplete"-style improvements that LLMs to programming are indications of massive deficiencies in programming: we're in many ways stuck in a ~2010-era model of what programming is, which is actually quite medieval and useless. Probably programs as "text that you run on a computer" is, long-term, not how anything is going to be done. After all, what is a prompt but a (lossy, err…

Right. If an LLM is capable of writing good boilerplate code for you then your programming language is too low level. We need higher level languages which abstract away most of the repetitive patterns. What would a language look like where the code has much higher "entropy" but is still human readable and maintainable? Like could we design a language that combines all of the productivity advantages of APL / Lisp / Pr…

I would argue that nowadays the libraries and frameworks are more to blame than the languages. We aren't creating the right elegant DSLs. But more importantly we're still expecting people to inherit from library classes — perhaps multiple levels deep — to swap functionality in and out. We could just use functions as first-class objects but instead we have to understand this unnatural intermingling of code and data that's based on "modeling" a supposed concept in the problem domain (rather than the solution domain) that barely makes any sense in and of itself. Like Rich Hickey explained (https://www.youtube.com/watch?v=SxdOUGdseq4), things become complex because you complect them.

You can get a lot of APL / LISP feeling out of carefully written Python or JavaScript. Not the metaprogramming stuff, sure. But a lot of that in LISP depends on homoiconicity, which is one of the biggest things making the language "not usable by average developers".

Re: Solving the Wrong Problem

#19
post #2

Feel this strongly. That all of the "autocomplete"-style improvements that LLMs to programming are indications of massive deficiencies in programming: we're in many ways stuck in a ~2010-era model of what programming is, which is actually quite medieval and useless. Probably programs as "text that you run on a computer" is, long-term, not how anything is going to be done. After all, what is a prompt but a (lossy, err…

> Can we formalize that abstraction such that the prompt is an exact specification, just, at a super high level

Every time people attempted on this they ended up with a programming language that is harder to use than usual programming languages.

SQL was marketed as "fourth-generation programming language."

Two other examples that come to mind: Github Actions, and node-based visual programming.

Re: Solving the Wrong Problem

#20
post #2

Feel this strongly. That all of the "autocomplete"-style improvements that LLMs to programming are indications of massive deficiencies in programming: we're in many ways stuck in a ~2010-era model of what programming is, which is actually quite medieval and useless. Probably programs as "text that you run on a computer" is, long-term, not how anything is going to be done. After all, what is a prompt but a (lossy, err…

> Can we formalize that abstraction such that the prompt is an exact specification, just, at a super high level Every time people attempted on this they ended up with a programming language that is harder to use than usual programming languages. SQL was marketed as "fourth-generation programming language." Two other examples that come to mind: Github Actions, and node-based visual programming.

ya I think it's possible to do vastly better than those
Post reply on HN