[HN Gopher] The art of programming and why I won't use LLM
___________________________________________________________________
The art of programming and why I won't use LLM
Author : theapache64
Score : 147 points
Date : 2024-08-25 17:47 UTC (5 hours ago)
(HTM) web link (kennethnym.com)
(TXT) w3m dump (kennethnym.com)
| chasingentropy wrote:
| I agree with your sentiment. It's like asking a 3 year old to
| compose a symphony because they learned to play twinkle twinkle
| little star on a casio keyboard reasonably well.
|
| I don't see it as a "judgemental piece to anyone that i am
| alluring to" (I think you mean alluding) but I do think it's an
| honest assesment of those who are attempting to rely heavily on
| AI.
| fsociety wrote:
| It is a judgemental piece because the writer is putting a value
| judgement on people who use LLMs to code and those who don't.
| Its right after the piece you quoted.
|
| > please don't take this as a judgemental piece to anyone that
| i am alluring to. it's fine to not find programming enjoyable.
| it's fine to just want things to work. i am just disappointed
| at how the ones who care appear to be an ever dying breed.
|
| I'm not saying the author shouldn't write that, write whatever
| you want. But you should own what you write.
| pandemic_region wrote:
| !remindme 1 year
| bena wrote:
| To be fair, we're almost 2 years from the release of ChatGPT
| and the "demise of the programmer".
|
| We've already did the speedrun from people styling themselves
| "prompt engineers" to people openly mocking people styling
| themselves "prompt engineers".
|
| And now it seems we're going to be "6 months to a year away
| from replacing programmers" for as long as it generates more
| funding.
| dakiol wrote:
| I do the "programming as art" in my free time, when working on my
| own side projects. I do it because it's fun and I take proud on
| what I produce.
|
| For work stuff? I couldn't care less if the code comes from me,
| my colleagues or an LLM. As long as it works and it's secure,
| we'll ship it.
|
| Folks, career != job.
| pajeets wrote:
| Exactly, now replace code with AI generated art, photos,
| drawings, videos, music. Your employers couldn't care less if
| its convincing enough to ship. even better now that it only
| takes seconds to minutes.
|
| We are at the cusp of creative destruction and we are only
| getting started. Ironically, blue collar jobs seem safe as
| there hasn't been a humanoid revolution and what I see in the
| white collar field is what blue collar workers experienced
| before the automation and offshoring of jobs
| steveBK123 wrote:
| I think AI art is actually an interesting example. It's
| mostly run of the mill schlock to replace clip art / stock
| images.
|
| Adequate but not enjoyable. Lorem ipsum of visual art.
| Probably kills some basic graphic design jobs at the margin
| working on low budget projects.
|
| Meanwhile big brands using big agencies will just incorporate
| it into their design process. McD Japan is a recent example.
| You still need a human with an eye and taste to be the
| editor.
|
| But no one is reading or viewing AI art for pleasure. It's
| all "that's neat" (continues scrolling).
| pajeets wrote:
| There are many erroneous assumptions based on conjectures
| and not enough real world metrics and evidences.
|
| AI art is very much already being consumed and sold. It's
| not just "mill schlock" anymore. You won't even know you
| are consuming AI art.
| thomashop wrote:
| Where are your real-world metrics and evidence?
| pajeets wrote:
| steveBK made the claim nobody is consuming AI arts
|
| he needs to prove that point
| layer8 wrote:
| Why would you spend 40-ish hours per week with stuff that isn't
| fun and you don't take pride in, if you have the choice?
| kqr wrote:
| > it is sad to me just how much people are trying to automate
| away programming and delegating it to a black box
|
| I take it you're not using a compiler to generate machine code,
| then?
|
| Scratch that, I guess you're not using a modern microprocessor to
| generate microcode from a higher-level instruction set either?
|
| Wait, real programm^Wartists use a magnetised needle and a steady
| hand.
|
| Programming has always been about finding the next black box that
| is both powerful and flexible. You might be happy with the level
| of abstraction you have settled on, but it's just as arbitrary as
| any other level.
|
| Even the Apollo spacecraft programmers at MIT had a black box:
| they offloaded the weaving of core rope memory to other people.
| Programming is not necessarily about manually doing the
| repetitive stuff. In some sense, I'd argue that's antithetical to
| programming -- even if it makes you feel artistic!
| jodhpurcapital wrote:
| Nailed it.
| csallen wrote:
| Thank you for saying this. It's always baffled me that people
| will decry ChangeX as unnatural and wrong when it happens in
| their lifetime, but happily build their lives upon
| NearlyIdenticalChangeY so long as it came before them.
| pottspotts wrote:
| We think of ourselves more intelligent than the generation
| before us, and more wise than the ones after.
| danielbln wrote:
| Makes you wonder if that sort of dynamic between
| generations is ever going to be something that can be
| overcome. Maybe if humanity cures aging.
| JimDabell wrote:
| _"I 've come up with a set of rules that describe our
| reactions to technologies:_
|
| _1. Anything that is in the world when you're born is normal
| and ordinary and is just a natural part of the way the world
| works._
|
| _2. Anything that 's invented between when you're fifteen
| and thirty-five is new and exciting and revolutionary and you
| can probably get a career in it._
|
| _3. Anything invented after you 're thirty-five is against
| the natural order of things."_
|
| -- Douglas Adams, The Salmon of Doubt: Hitchhiking the Galaxy
| One Last Time
| stavros wrote:
| This is so accurate I'm offended.
| eternauta3k wrote:
| There is a difference between those abstraction levels: with
| LLMs you are moving into the realm of management.
| mypalmike wrote:
| That was precisely the goal of many high level languages.
| layer8 wrote:
| ...which all failed for that reason.
| rstat1 wrote:
| Saying a compiler, and an "AI" hallucination model are even
| remotely the same is a pretty huge stretch.
| trueismywork wrote:
| Well, AI models don't have to hallucinate.
| thaumasiotes wrote:
| True, but LLMs do.
| KeplerBoy wrote:
| All current LLMs do though.
| disconcision wrote:
| how do you figure? people were making directly analogous
| arguments about compilers back in the day. (not trying to
| argue that they are 'the same', but their is definitely a
| spectrum of code generation methods, with widely varying
| genres of guarantees, suiting a widely varying range of use
| cases)
| lovethevoid wrote:
| They aren't saying they're the same, I'm not sure how you got
| that interpretation. It's very clear they're highlighting the
| hypocrisy that arises from claiming to be against automating
| away aspects of programming while relying on tools that do
| exactly that for you - only being Ok with it as long as they
| aren't called "AI".
| advael wrote:
| The crux of why this is a bad analogy is that everyone
| talking about "automating" things with LLMs is misusing the
| word "automation". A machine can automate a repetitive
| manual task. A computer can automate the operation of
| machinery. A machine instruction set is an abstraction on
| top of circuitry that can automate the labor of
| extrapolating the logic physically executed by that
| circuitry into human-comprehensible routines. In the same
| way, a programming language implemententation (e.g. a
| compiler) can somewhat automate programming (in the sense
| that it uses higher levels of abstraction to describe the
| same thing, saving labor while keeping determinism). What
| do these things have in common? We can reliably make them
| approach deterministic behavior. In the case of compilers,
| completely and reliably and transparently so. Just because
| you haven't bothered to read what a compiler is doing
| doesn't mean someone can't verify what it's doing. Physical
| machines are less reliable, but we have reliable ways to
| test them, reliable error margins, reliable failure modes,
| reliable variance. When you are on a stack of abstractions
| like a programming language on top of a compiler on top of
| transistors on top of a machine, an error at the top of
| that stack can have a lot of implications. A tool that
| probabilistically generates code is not automation. We have
| no guarantees about how and when it will get things wrong,
| how much this will happen, and what kinds of things it will
| get wrong. We have no way to audit their results that will
| generalize to every problem upstream of them. We have no
| way to reliably measure improvement in consistency, let
| alone improve that margin of error reliably. The entire
| idea that this is an automation at all is nonsense.
| conradev wrote:
| They're extremely different. But you can certainly use them
| together. Thus, new tools:
|
| https://ai.meta.com/research/publications/meta-large-
| languag...
| yes_man wrote:
| I get the point that they are in different magnitudes of
| unknown but the analogy is still pretty good when it comes to
| the median programmer, who has no idea what goes on within
| either one. And if you argue that compilers are ultimately
| deterministic, that same argument technically holds for an
| LLM as well.
|
| The biggest difference to me is that we have humans that
| claim they can explain why compilers work the way they do.
| But I might as well trust someone who says the same about
| LLMs, because honestly I have no way to verify if they speak
| the truth. So I am already offloading a lot of burden of
| proof about the systems I work on to others. And why does
| this "other" need to be a human.
| milemi wrote:
| This is like saying "I don't understand how airplanes fly,
| so I'll happily board an airplane designed by an LLM. The
| reality is determined by how much I know about it."
| yes_man wrote:
| No, the other way around. I am saying it is not a smart
| take to say "a safe airplane cannot be built if LLMs were
| used in the process in any way, because reasons". The
| safety of the airplane (or more generally the outcome of
| any venture) can be measured in other ways than leaning
| on some rule that you cannot use an LLM for help at any
| stage because they are not always correct
| habosa wrote:
| While the base of your argument is true, it's also a bit
| dishonest. LLMs are significantly different than any of these
| other abstractions because they can't be reasoned about or
| meaningfully examined/debugged. They're also the first of these
| advances which anyone has claimed would eliminate the need for
| programmers at all. I don't believe the C compiler was meant to
| do my whole job for me.
| spencerchubb wrote:
| I don't buy that you're actually examining compiled programs.
| Very few people do. Theoretically you _could_ , but the whole
| point of the compiler is to find optimizations that you
| wouldn't think of yourself.
| bena wrote:
| No, the point of the compiler is to translate code into
| machine instruction.
|
| Yes, it _can_ optimize things for you, but that is not its
| purpose.
| kibwen wrote:
| The point of an optimizing compiler is to find
| optimizations which, crucially, are semantics-preserving.
| This is the contract that we have with compilers, is the
| reason that we trust them to transform our code, and is the
| reason why people get up in arms every time some C compiler
| starts leveraging undefined behavior in new and exciting
| ways.
|
| We have no such contract with LLMs. The comparison to
| compilers is highly mistaken, and feels like how the
| cryptocurrency folks used to compare cryptocurrency to
| _gestures vaguely_ "the internet" in an attempt to
| appropriate legitimacy.
| Jensson wrote:
| > I don't buy that you're actually examining compiled
| programs. Very few people do
|
| I take it you don't write C, C++, or any language at that
| level? It is very common to examine compiled programs to
| ensure the compiler made critical optimizations. I have
| done that many times, there are plenty of tools to help you
| do that.
| trueismywork wrote:
| Current LLMs, we do not know that we cannot have future LLMs
| which can be almost formal. Think mathematics written in
| English and LaTeX
| card_zero wrote:
| If using an LLM meant carefully crafting a complex,
| precise, formal prompt that specified only one possible
| output, I might be interested. But then I wonder if the
| prompt would be very much shorter.
|
| Thinking about it, this depends on which differences we
| consider _aspects of the output program,_ and which ones we
| consider _trivial differences that don 't count._ If you
| say "build an RPG about dragons with a party of magic using
| heroes" and the LLM spits one out, you reached a level of
| abstraction where many choices relating to taste and
| feeling and atmosphere (and gameplay too) are waved aside
| as trivial details. You might extend the prompt to add a
| few more, but the whole point of creating a program this
| way is not to care about most of the details of the
| resulting experience. Those can be allowed to be generic
| and bland, right? Unless you care about leaving your
| personal touch on, say, all of them.
| nyrikki wrote:
| Things constructivist mathematics cannot do:
|
| 1) Prove Addition of natural numbers.
|
| 2) Prove two real numbers are equal.
|
| RNNs are only TC with infinite precision and unlimited
| resources, once you have finite precision they are very
| limited.
|
| LLMs do not have recursion at all and can't even emulate
| finite automations. In fact soft attention can only emulate
| TC_0
|
| Feed forward networks are effectively DAGs and with soft
| attention, DAGs built with AND,OR, NOT, and threshold
| circuits.
|
| One of the state of the art inference in code methods is
| bi-abduction, probably best described here.
|
| https://fbinfer.com/docs/separation-logic-and-bi-abduction/
|
| But this localization makes it computationally possible,
| and has limits.
|
| The qualification and frame problems, combined with the
| very limited computational power of transformers is another
| lens.
|
| LLMs being formalized doesn't solve the problem. Fine
| tuning and RAG can help with domain specificity, but
| hallucinations are a fundamental feature of LLMs, not a
| bug.
|
| Either a use case accepts the LLM failure mode (competent,
| confident, and inevitably wrong) or another model must be
| found.
|
| Godel showed us the limits of formalization, unless we find
| he was wrong, that won't change.
| DougN7 wrote:
| I think you're assuming your reference is the correct one. I
| can't reason about the assembly language that the compiler
| spits out, the microcode in the CPU kernel or any of the
| electronics on the motherboard. That anyone can or not
| doesn't change things in my opinion. It's an arbitrary
| distinction to say _this_ abstraction is uniquely different
| in this very specific way.
| grey-area wrote:
| Compilers are deterministic.
|
| LLMs are not.
| yodon wrote:
| >Compilers are deterministic
|
| They seem that way, until you're tasked with getting a
| repeatable, idempotent build out of a non-trivial build
| system.
| marcinzm wrote:
| LLMs are deterministic if you force a seed or disable
| sampling. They however do not guarantee that small input
| changes will cause small output changes.
| Jensson wrote:
| > LLMs are deterministic if you force a seed or disable
| sampling
|
| Not with todays GPU's, you would need to run it locally
| with special GPU settings or run it on your CPU to ensure
| it is deterministic.
| DougN7 wrote:
| So? Compilers compile and LLMs do not. Compilers use
| linkers and LLMs do not. Arbitrary distinctions don't
| means "this time it's different".
| kqr wrote:
| Cobol and other early high-level languages were designed with
| the intention of allowing businesspeople to write their own
| programs so programmers wouldn't be needed. Some people
| really believed that!
| evilduck wrote:
| SQL too.
| lukeschlather wrote:
| I'd really like to have everything written in Rust, not C.
| Rust does a lot of verification, verification that is very
| hard to understand. I'd like to be able to specify a function
| with a bunch of invariants about the inputs and outputs and
| have a computer come up with some memory-safe code that
| satisfies all those invariants and is very optimized, and
| also have a list of alternative algorithms (maybe you discard
| this invariant and you can make it O(nLog(n)) instead of
| O(n^2), maybe you can make it linear in memory and constant
| in time or vice versa...)
|
| Maybe you can't examine what the LLM is doing, but as things
| get more advanced we can generate code to do things, and also
| have it generate executable formal proofs that the code works
| as advertised.
| monooso wrote:
| I agree with the second part of your argument, regarding the
| assertion that LLMs may eventually replace programmers.
|
| However, I don't understand your claim that an LLM acting as
| a programming assistant "...can't be reasoned about or
| meaningfully examined/debugged."
|
| I type something, and Copilot or whatever generates code
| which I can then examine directly, and choose to accept or
| reject. That seems much easier to reason about than what's
| happening inside a compiler, for example.
| minkles wrote:
| Um those black boxes have determinism.
| kqr wrote:
| Not at all. See the cries for reproducible builds, exploits
| like Spectre etc.
| fire_lake wrote:
| You are precisely right but practically wrong here
| pajeets wrote:
| We can argue the same thing for artists. Who wrote the
| algorithms for your favorite Photo/Image editor? Who created
| the image formats and standards, infrastructures for you to be
| able to push binary files to millions of people?
| Palomides wrote:
| there's a strict contract between the programmer and the
| compiler (the language spec)
| MarkusQ wrote:
| Which would be relevant if either side respected it.
|
| In practice, compilers frequently have bugs and programmers
| even more frequently make use of "what the compiler actually
| does" rather than adhering to the language specification --
| to the point where the de facto spec for many languages is
| "what the canonical implementation does".
|
| And the specifications change over time.
| kibwen wrote:
| The frequency with which compiler implementations
| functionally diverge from language specifications is
| dwarfed, by many orders of magnitude, by the frequency with
| which LLMs generate provably nonsensical code in response
| to a prompt.
|
| To wit, a compiler diverging from the specification is so
| relatively rare that people will get angry about it and
| demand that it be fixed, while an LLM spewing creative
| nonsense is so accepted and par for the course that
| complaining about that fact is met with a shrug and "well,
| what did you expect?"
| layer8 wrote:
| LLMs don't have a canonical output that could serve as a
| specification. And if they had, we wouldn't consider that a
| satisfactory specification at all.
| milemi wrote:
| You can learn how compilers work and understand how they do
| what they do. Nobody understands what's in those billions of
| parameters, and no one ever will.
| fuzztester wrote:
| why are there so many parameters in the first place? and was
| it humans who generated so many? seems like a very big job
| for a human to do, or even a team of humans to do.
|
| disclaimer: I know next to nothing about llms. and I'm not
| that interested to learn about them. just asking casually.
| jdiff wrote:
| They're not manually generated or anything, it's just a
| setting. Too few and the model doesn't have enough
| flexibility to capture complex patterns. Too many and the
| model can just memorize the data you train it on rather
| than capturing the patterns driving it.
| Jensson wrote:
| > why are there so many parameters in the first place?
|
| Because parsing and writing human language in a natural way
| is extremely complex.
|
| > and was it humans who generated so many?
|
| No, it is generated using an algorithm that tries to
| predict the next word in human written text using the words
| that comes before it. It ingests basically all the text on
| the internet to do this, without that much text the LLM
| performs horribly.
| throwaway22032 wrote:
| I don't think that this is a fair comparison because at some
| point the nature of the craft actually does change.
|
| To give an analogy, a carpenter might be happy with hand tools,
| happy with machine tools, happy with plywood, and happy with
| MDF. For routine jobs they may be happy to buy pre-fabbed
| cabinets.
|
| But for them to employ an apprentice (AI in this example) and
| outsource work to them - suddenly they are no longer really
| acting as a carpenter, but a kind of project manager.
|
| edit: I agree that LLMs in their current state don't really
| fundamentally change the game - the point I am trying to make
| is that it's completely understandable that everyone has their
| own "stop" point. Otherwise, we'd all live in IKEA mansions.
| kqr wrote:
| Running state of the art LLMs for programming is nowhere near
| project management. At least in my experience, all LLMs are
| really good at is dumping plausible tokens quickly. They
| can't think, design, or handle tradeoffs intelligently.
|
| They help me with the keyboard work, not any of the actual
| programming.
| jclulow wrote:
| An apprentice is another person performing the same kind of
| work as the carpenter. That's fundamentally different from
| using an LLM, which is not a person and does not function
| like a person.
|
| Whether you think LLMs are spectacularly worthwhile or odious
| and destructive, it's crucial not to classify them as being a
| person instead of a software tool.
| fuzztester wrote:
| yep, I would call this the anthropomorphisation of llms.
| undesirable, just as any other kind of anthropomorphisation
| is.
| kif wrote:
| This is a very poor analogy. It's not a matter of abstractions,
| it's a matter of getting someone or something else to do the
| work, while you mostly watch and fix any errors you're able to
| catch.
| discreteevent wrote:
| HN commenter: Samuel, why don't you use an LLM to write this
| play you are working on?
|
| Beckett: What?
|
| HN commenter: Well it's just like when you decided to work in
| French instead of English. Your art was no less because of it.
| Now you can use an LLM instead of French. It will be so much
| quicker.
| YeGoblynQueenne wrote:
| >> I take it you're not using a compiler to generate machine
| code, then?
|
| The dismissive glibness of your comment makes me wonder if it's
| worth it trying to point out the obvious error in the analogy
| you're making. Compilers translate, LLMs generate. They are two
| completely different things.
|
| When you write a program in a high-level language and pass it
| to a compiler, the compiler translates your program to machine
| code, yes. But when you prompt an LLM to generate code, what
| are you translating? You can pretend that you are "translating
| natural language to code" but LLMs are not translators, they're
| generators, and what you're really doing is providing a prefix
| for the generated string. You can generate strings form an LLM
| with an empty prefix; but try asking a compiler to compile an
| empty program.
|
| >> Even the Apollo spacecraft programmers at MIT had a black
| box: they offloaded the weaving of core rope memory to other
| people.
|
| You're referring to core rope memory:
|
| https://en.wikipedia.org/wiki/Core_rope_memory
|
| There is no "black box" here. Programmers created the program
| and handed it over to others to code it up. That's like hiring
| someone to type your code for you at a keyboard, following your
| instructions to do so. You have to stretch things very far to
| see this as anything like compilation.
|
| Also, really, compilers are not black boxes. Just because most
| people treat them as a scary unknowable thing doesn't mean
| that's what they are. LLms are "black boxes" because no matter
| how much we peer at their weights, arrays of numerical values,
| there's nothing we can ... er ... _glean_ from them. They 're
| incomprehensible to humans. Not so the code of a compiler. Even
| raw binary is comprehensible, with some experience.
| CJefferson wrote:
| I recently had used an LLM to convert a lot of Python to
| Rust. It got it 99% right, and it took me a short while to
| fix the compile-time errors, and carefully check the tests
| weren't broken (as I trusted the code worked when the tests
| passed).
|
| Is that "compiling" or "translating"? Lots of people use
| language to C "compilers".
| shepherdjerred wrote:
| Compilation is generally deterministic with strict
| semantics.
|
| LLMs are great, but they are the opposite of a compiler (in
| a good way)
| creesch wrote:
| Both of them are black boxes though by the author's own
| definition.
| szundi wrote:
| Exactly
| elric wrote:
| I get what you're trying to say, but I don't entirely agree.
| Raising levels of abstraction is generally a good thing. But up
| until now, those have mostly been deterministic. We can be
| mostly confident that the compiler will generate correct
| machine code based on correct source code. We can be mostly
| confident that the magnetised needle does the right thing.
|
| I don't think this is true for LLMs. Their output is not
| deterministic (up for discussion). Their weights and the
| sources thereof are mostly unknown to us. We cannot really be
| confident that an LLM will produce correct output based on
| correct input.
| computerex wrote:
| So what if the output is stochastic? LLM's have self
| consistency, so you can repeat the inference several times
| and pick the most frequent output.
| saulpw wrote:
| And you can pay in time and/or $$ for the privilege of
| having to do do this extra unnecessary work.
| dazilcher wrote:
| Most frequent output does not imply correctness, LLMs often
| are confidently wrong.
|
| They can't even perform basic arithmetic (which is not
| surprising since they operate at the syntactic level,
| oblivious to any semantic rules), yet people seem to think
| offloading more complex tasks with strict correctness
| requirements is a good idea. Boggles the mind tbh.
| quaintdev wrote:
| What if the we can't do abstraction anymore. I mean we
| certainly can but we will loose ability to configure tiny
| details of system.
|
| So other path forward could very well be LLMs as they can
| save lot of time with writing boilerplate code
| krageon wrote:
| For the average programmer the infinite layers of
| abstraction, libraries and middleware isn't deterministic
| either. The LLMs actually honest to god being probabilistic
| estimators doesn't change anything about what they produce or
| how they see their own stuff.
| mxkopy wrote:
| I'd say it's not only determinism, but also the social
| contract that's missing.
|
| When I'm calling 'getFirstChar' from a library, me and the
| author have a good understanding of what the function does
| based on a shared context of common solutions in the domain
| we're working in.
|
| When you ask ChatGPT to write a function that does the same,
| your social contract is between you and untold billions of
| documents that you hope the algorithm weights correctly
| according to your prompt (we should probably avoid
| programming by hope).
|
| You could probably get around this by training on your
| codebase as the corpus, but until we answer all the questions
| about what that entails it remains, well, questionable.
| LoganDark wrote:
| > we should probably avoid programming by hope
|
| I use Cursor at work, which is basically VSCode + LLM for
| code generation. It's a guess and check, basically. Plenty
| of people look up StackOverflow answers to their problem,
| then verify that the answer does what they want. (Some
| people don't verify but those people are probably not good
| programmers I guess.) Well, sometimes I get the LLM to
| complete something, _then verify the code is completed is
| what I would have written_ (and correct it if not). This
| saves time /typing for me in the long run even if I have to
| correct it at times. And I don't see anything wrong with
| this. I'm not programming by hope, I'm just saving time.
| layer8 wrote:
| This increases the time you spend proofing other's work
| (tedious) versus time you spend developing a solution in
| code (fun). Also, if the LLM output is correct 95% of the
| time, one tends to get more sloppy with the checking, as
| it will feel unnecessary most of the time.
| szundi wrote:
| Just what I was thinking about lately, what if LLMs are
| not 95% precise, but 99,95%. After like 50-100 checks you
| find nothing, and you just dump the whole project to be
| implemented - and there come the bugs.
|
| However ... your colleagues just do the same.
|
| We'll see how this unfolds. As for now the industry seems
| to be a bit stuck at this level. Big models too expensive
| to train for marginal gains, smaller are getting better
| but doesn't help this. Until some one new idea comes in
| how LLMs should work, we won't see the 99.95% anyway.
| layer8 wrote:
| Yeah, I'm more worried about the middle ground that would
| make software quality (even) worse than it is today.
| Wowfunhappy wrote:
| I agree with you but I want to try to define the language
| better.
|
| It's not that LLMs aren't deterministic, because neither are
| many compilers.
|
| It's also not that LLMs produce incorrect output, because
| compilers do that to, sometimes.
|
| But when a compiler produces the wrong output, it's because
| either (1) there's a logic error in my code, or (2) there's a
| logic error in the compiler+, and I can drill down and figure
| out what's going on (or enlist someone to help me) to fix the
| problem.
|
| Let's say I tell an LLM to write a algorithm, and it produces
| broken code. Why didn't my prompt work? How do I fix it? Can
| anyone ever actually know? And what did I learn from the
| experience?
|
| ---
|
| + Or I guess there could be a hardware bug. Whatever. I'm
| going to blame the compiler because it needs to produce bytes
| that work on my silicon regardless of whether the silicon
| makes sense.
| shafyy wrote:
| Compilers are deterministic
| codebje wrote:
| This is in general only true for either trivial toy
| compilers or ones which have gone to lengths to have
| reproducible builds. GCC for instance uses a randomised
| branch prediction model in some circumstances.
| szundi wrote:
| Arguing with compilers about LLM determinism is not really
| adequate as an analogy, completely misses the point on
| purpose
| rodrigosetti wrote:
| This is a qualitatively different kind of abstraction. All
| other abstractions still require the programmer to express the
| solution in a formal language, while LLMs are allowing the user
| to express the solution in natural language. It's no longer
| programming, but much more like talking to a programmer as a
| manager.
| freetanga wrote:
| By that light, the artist that is painting using store-bought
| pigments instead of hand made, or brushing paints instead of
| reallocating molecules, or even better, atoms, is also using a
| black box.
|
| I think OP has a point, and is about guiding the design, then
| overall structure and dynamic of the code. Nobody expects to
| write in Assembler or not using libraries, but making a
| concious decision on the design.
|
| I have met few programmers, but many coders. For them coding is
| a job, and generally they don't care about overall
| architecture, algorithm efficiency, and code elegance is
| limited to syntax-coloring-themes in their editor. I respect
| their existence, but generally they are building on top off
| somobody else's effort.
| lagrange77 wrote:
| I guess we are currently in the special situation, that we as
| human programmers can understand the output of a coding LLM.
| That's because programming languages are designed to be human
| readable. And we had an incentive to learn those languages.
|
| I imagine that machine learning powered coding will evolve to
| an even blacker box, than it is today: It will transform
| requirements to CPU instructions (or GPU instructions,
| netlists, ...). Why bother to follow those indirections, that
| are just convenience layers for those weak carbon units (urgh)?
|
| Simultaneously, automation will likely lead to fewer skilled
| programmers in the future, because there will be fewer
| incentives to become one.
|
| Together those effects could lead to a situation where we are
| condemned to just watch.
| kalind wrote:
| So what do you do when the LLM creates a bug in a multi-
| million CPU instruction program it generated and you can't
| prompt it to fix the bug?
| lagrange77 wrote:
| Yeah, good question. You could ask the same question for
| today's or near future coding LLMs used by non programmers.
| amelius wrote:
| >> delegating it to a black box
|
| > I take it you're not using a compiler to generate machine
| code, then?
|
| An LLM is much, much closer to a "black box" than a compiler
| ...
|
| In fact, an LLM is pretty much a black box even to the people
| who created it.
| toprerules wrote:
| Your argument is a false dichotomy and thus a logical fallacy.
| Not all steps forward in abstraction or code generation are
| necessary good steps and have to be considered on their own
| merits. If LLMs are indeed superior, then you should be able to
| articulate their merits without condescending to fallacious
| attacks.
| mgaunard wrote:
| The transformations you're referring to are fully deterministic
| and guaranteed to be correct.
|
| LLMs provide statistically probable answers with no guarantee
| of correctness. It takes more time to review LLM code than it
| takes to write it correctly from scratch.
| tpoacher wrote:
| I 100% agree with you. Whenever I see artists buy their brushes
| I cringe. Real artists don't draw anything until they've grown
| a tree and raised horses to obtain the raw materials (wood and
| horse hair) to make their first brush.
|
| Using a bought brush to paint and generating a painting via a
| prompt are basically identical.
|
| /s
| bayindirh wrote:
| The thing is, all these stacks are built by people and verified
| against specifications. When they failed to perform the way
| they should, we fixed them.
|
| Plus, all the parts are deterministic in this stack. Their
| behavior is fixed for a given input, and all the parts are
| interpretable, readable, verifiable and observable.
|
| LLMs are none of that. They are stochastic probability
| machines, which are nondeterministic. We can't guarantee their
| output's correctness, and we can't fix them to guarantee
| correct output. They are built on tons of (unethically sourced)
| data, which has no correctness and quality guarantees.
|
| Some people will love LLMs, and/or see programming as a
| task/burden they have to complete. Some of us love programming
| for the sake of it, and earn money by doing it that way, too.
|
| So putting LLMs to the same bucket with a deterministic, task
| specific programming tool is both wrong, and disservice to
| both.
|
| I'm also strongly against LLMs, not because of the tech, but
| because of how they are trained and how their shortcomings are
| hid and they're put forward as the "oh the savior of the woeful
| masses, and the silver bullet of all thy problems", and it's
| neither of them.
|
| LLMs are just glorified tech demos which shows what stochastic
| parrots can pose as accomplishing when you feed the whole world
| to them.
| red75prime wrote:
| > We can't guarantee their output's correctness
|
| We can (for programming, at least): run the output thru
| theorem prover, ensure that proof is constructive, the Curry-
| Howard correspondence guarantees that you can turn the output
| into a correct program. It doesn't guarantee that formal
| properties of the program correspond to the informal problem
| statement. But even people occasionally make such errors (a
| provably correct program doesn't do what we wanted it to do).
|
| > and we can't fix them to guarantee correct output
|
| Same thing with other systems capable of programming. That is
| people.
|
| You just can't make a system that guarantees correct
| transformation from an informal problem statement into a
| formally correct implementation. "Informal" implies that
| there's wiggle room for interpretation.
|
| No, it doesn't mean that current LLMs are ready to replace
| programmers, it also doesn't mean that ML models of 2030s
| will not be able to.
| bamboozled wrote:
| This doesn't mean the LLM is deterministic. It means it can
| spoof the right answer give enough time.
| red75prime wrote:
| Indeterminism is not always bad. A probabilistic Turing
| machine is more powerful than a Turing machine, for
| example (BPP complexity class is a superset of P).
| skybrian wrote:
| Yep. LLM's don't guarantee any interesting mathematical
| properties. That's up to you.
|
| This why you should write good tests, review the code, and
| don't approve anything you don't understand.
|
| It's not a reason to reject pretty good autocomplete, though.
| carapace wrote:
| This is _completely_ wrong.
|
| Compilers are complex programs fraught with bugs. Modern
| microprocessors are hideously complex devices fraught with
| bugs. But at least we understand them in principle and
| practice.
|
| LLMs are nonsense generators, you need a second device that can
| recognize correct programs to use them effectively. Only humans
| can do that all-important second part.
|
| > Programming has always been about finding the next black box
| that is both powerful and flexible.
|
| That's the opposite of programming. Programming is the art and
| science of developing _reliable algorithms_. You can treat
| programs as black boxes only after you 're sure that they work
| correctly. Otherwise you're just engaged in a kind of cargo
| cult.
|
| That the scary thing about the LLM fad: so many people seem so
| willing to abdicate their responsibility to actually think.
| w0m wrote:
| Reminds me long ago of working with a guy that did everything
| in C when we were rewriting things in Perl . Yes, his stuff was
| faster. Yes, it was also buggier, harder to debug, and took 3x
| as long to write for similar levels of functionality (it wasn't
| speed dependent code by any stretch.)
| pajeets wrote:
| This feels exactly like the manifesto that artists on X started
| defending that Ai-generated Art isn't Art but look where we are
| now, companies are able to generate not only quality Art assets
| but photos too but amateur consumers creating songs, videos,
| pictures that they couldn't have previously.
|
| Unlike art where you can tell if the end product is AI generated
| even, software is not. The end users do not care if you used AI
| to generate your react front-end or back-end, your employers dont
| care who wrote the code as long as its bug free and works like in
| the scope document.
|
| Ironically, I don't see software developers writing manifestos or
| complaining that AI generated software isn't software or that
| they are stealing from them.
| brailsafe wrote:
| Seems to me like art is art if the person who made it feels
| that it's art, and that may or may not be a component of the
| process that went into an apparently artistic product. Artistic
| products seem more likely to be "art" of there's no specific
| value to them, and they exist to exist or to add some abstract
| element of decoration to world. A former theatre friend of mine
| once got mad when I described art as having no intrinsic value,
| but that doesn't mean it has no value, and I don't think it
| fundamentally changes the non-art noun of what's produced; a
| painting/print can be just a decoration, and/or it can be art,
| but the fact that it's art doesn't change whether it's a
| painting or a decoration or the type of object. That may not be
| the case of course if the resulting object is an artistic
| illusion, such as a table that's not a functional table because
| it's made of cake, but again I don't think it needs to get that
| deep for the point to be true.
|
| Likewise, software that was produced artistically may or may
| not be better, or more valuable, or distinguishable in any way
| from other software products, but if the author feels like it's
| art it may be art. That may be because there's no tangible
| reason for it to exist other than a creative endeavor, in which
| case maybe it's not actually software.
| pajeets wrote:
| what is "artistically produced software", I'm genuinely
| curious as to how a CRUD app for enterprise is "artistic"
|
| are you talking about games? thats not really what article
| author was speaking to.
| Retr0id wrote:
| Writing an essay forces you to think about an idea intimately,
| acting as a tool for thought in and of itself. The way I use
| programming is the same.
| habosa wrote:
| I tend to agree with this post. I am the only person on my team
| and one of the few at my company not using LLMs to assist my
| programming. So far I don't think I notice any difference (better
| or worse) ... we'll see how this experiment plays out I guess.
| personalityson wrote:
| I only use it to name my functions and variables
| marcinzm wrote:
| I find the post confusing. The author notes two aspects of
| programming and then seems to conflate LLMs as doing both when
| they only do the second. It's sort of like saying directing a
| movie isn't art or creative because the director is not every
| actor in the movie?
| rongald wrote:
| I suppose I get where the sentiment is coming from and anybody
| can use whichever tools make them happy but I feel like the
| comparison doesn't make too much sense to me. As programmers we
| leverage so many levels of abstraction that help us write better
| code. It feels similar to saying if you use some package or
| library you're letting some library author do the painting for
| you. Or if you use a high level language instead of assembly
| you're letting a compiler do the painting for you.
| Icarus-maximus wrote:
| Undead
| sibeliuss wrote:
| I think of myself as a code artist too but definitely not leaving
| the productivity boost of an LLM behind. The thing just helps me
| write stuff that I was going to write anyways!
| yowayb wrote:
| LLMs are just aggressive auto-complete. Yes, overhyped naturally.
| But also still saving me keystrokes!
| PaulHoule wrote:
| Comparing an LLM to an artist who can paint for you is giving it
| too much credit.
| williamcotton wrote:
| I still very much felt like I was creatively crafting this [0]
| project even though the entire approach used the Claude project
| feature. I had to hand-write some sections but for the most part
| I was just instructing, reading, refining, and then copying and
| pasting. I was the one who instructed the use of a bash parser
| and operating on the AST for translation between text and GUI. I
| was the one who instructed the use of a plugin architecture to
| enforce decoupling. I was the one who suggested every feature and
| the look of the GUI. The goal was to create an experimental UI
| for creating and analyzing bash pipelines. The goal was not to do
| a lot of typing!
|
| These high level abstractions are where I find the most joy from
| programming. Perhaps for some there is still some modicum of
| enjoyment from writing a for loop but for most people twenty
| years into a career there's nothing but the feeling of grinding
| out the minutia.
|
| There's still a lot of room for better abstractions when it comes
| to interfacing with computing devices. I'd love to write my own
| operating system, CLI interface, terminal, and scripting
| language, etc from scratch and to my own personal preferences. I
| don't imagine I could ever have the time to handcraft such a vast
| undertaking. I do imagine that within a few decades I will be
| able to guide a computing assistant through the entire process
| and with great joy!
|
| [0] https://github.com/williamcotton/guish
| umvi wrote:
| For me LLMs are like programming power tools. Use them wrong and
| you can hurt yourself. Use them right and you can accomplish far
| more in the same amount of time.
|
| People that refuse to program with AI or intellisense or any
| other assistance are like carpenters who refuse to build
| furniture with power saws and power drills. Which is perfectly
| fine, but IMO that choice doesn't really affect the artistry of
| the final product
| throwup238 wrote:
| _> For me LLMs are like programming power tools. Use them wrong
| and you can hurt yourself. Use them right and you can
| accomplish far more in the same amount of time._
|
| Fun analogy because if you're especially negligent you can
| injure yourself so badly you'll make programming forever more
| difficult than it needs to be or end your career altogether -
| like with a tablesaw cutting off fingers.
| fuzztester wrote:
| intellisense is fine, but high speed chopping off of your limbs
| is not. the two are not comparable.
| bongodongobob wrote:
| Seeing luddism in programming is hilarious to me. Keep writing
| your machine code old man, we'll pick up the slack for you while
| you fade into obscurity.
| paretoer wrote:
| But it will cause a reduction in wages and the quality compared
| to hand crafted fabrics will be inferior when automated.
| youssefabdelm wrote:
| > does no one not find programming fun anymore?
|
| Author needs to get into Bret Victor. Has no idea how much more
| fun he could be having.
|
| Programming is a step on the way to access to the state space of
| information. When we get to that stage, programming will seem
| like a maze of syntax, that has its own idiosyncrasies that force
| you into corners or regions in the state space, just like any DAW
| plugin or 3D tool, or any tool at all that exists.
| globular-toast wrote:
| The six year old English took me more effort to read than it
| should. The point of language is to communicate. Write in a way
| that people can read.
|
| But to the point of the post, yeah, I agree. The people using
| LLMs are just using it to compensate for a horrible toolkit. It
| doesn't help them think or break down problems that nobody has
| seen before. If it makes them quicker it's because they were
| using caveman-level tools before. I haven't typed every character
| in the code I produce for at least a decade at this point. Most
| of my time and effort is in thinking. But for braindead code
| monkeys, sure, anything will make you quicker.
| WithinReason wrote:
| An LLM would have made zero spelling and punctuation mistakes
| globular-toast wrote:
| I have wondered whether one day people might attempt to prove
| their "realness" by writing in an intentionally stupid way
| that an LLM could never write.
| drawback wrote:
| That might be true for American English. LLMs are bad in my
| language and can not produce long texts without obvious
| mistakes just yet.
| steveBK123 wrote:
| I do sometimes get the impression that there will be a
| generational gap in ability to code between millennials and
| zoomers.
|
| We had an overdemand for devs during late ZIRP early COVID
| leading to bootcamps and self taught pulling a lot of untrained
| into the industry. Many of them have left the industry.
|
| Add to that the whole data science bubble and it's bursting where
| we had tons of degrees and job openings for sort-of-devs. Lot of
| those jobs are gone now too.
|
| Don't forget the pull of "product management" and its demise
| outside big tech.
|
| Now we have hiring freezes and juniors leaning on LLMs instead of
| actually spending an hour trying to solve problems.
|
| Interesting times.
| rjakobsson wrote:
| Amen!
| indigodaddy wrote:
| "please don't take this as a judgemental piece to anyone that i
| am alluring to"
|
| I would never judge anyone who finds your non-capitalized,
| grammatical-error ridden essays seductive.
| danjl wrote:
| I'll take bad grammar and spelling over hallucinations, bugs,
| and poor design any day.
| indigodaddy wrote:
| Lol, yeah I was being cheeky here but when I see so many
| spelling / grammar related mistakes, I wonder can they not at
| least put the text through Microsoft Word or something?
|
| Do we have grammar/spelling checkers for markdown editors or
| whatever most are using to write their blogs?
| infinitezest wrote:
| Unlike with all of the human-coded software which is all bug-
| free and "well-designed" (whatever that means).
|
| Maybe the author should have had the LLM write the article
| while they wrote software instead. Play each to their
| strengths.
| creesch wrote:
| What is up with these blogs that are apparently not made with the
| purpose of being read? Having sentences not start with uppercase
| letters really makes it one big mesh of letters. Certainly when
| they are run-on sentences only separated by commas.
|
| Not helped by the choice of using a monospaced font. I get that
| it is often an aesthetic choice, but given that a blog post is
| written with the idea to be read, one I don't think is a
| particularly good one. Although the last time I made a remark
| about that on HN it became clear to me that a lot of people don't
| see the issue. Even if there are decades worth (at this point) of
| research that makes it clear that a sans serif font (or even a
| serif font on modern displays) works better for readability.
| -\\_(tsu)_/-
|
| In this case though, the combination of the monospaced font,
| everything being in lowercase and the run-on sentences I really
| am scratching my head here.
|
| Are you trying to get a message out there? Or are you mostly
| going for aesthetics?
| kccqzy wrote:
| The author simply hasn't learned anything at all about the art
| of typography and typesetting.
| creesch wrote:
| Below you'll find the fixed version an LLM provided. I simply
| asked it to add uppercase letters where appropiate and split up
| sentences where needed. You are welcome:
|
| ---
|
| As LLMs get better and better at writing code, more and more
| people, at least on twt, have started to incorporate LLMs into
| their workflow. Most people seem to agree that LLMs have been a
| game changer for coding. They praise them for how much they
| have improved their productivity. They also mention how much
| easier it is to write code. Some claim that programmers who
| refuse to use them are "not using them correctly" and will
| eventually get left behind.
|
| In my opinion, the effectiveness of LLMs in coding at their
| current state is vastly overblown. Even if LLMs were as good as
| what avid users of them claim, I still won't see myself using
| it in any meaningful capacity.
|
| ## The art of programming
|
| Programming can be broken down into two parts. The first is
| solving problems algorithmically, breaking problems into steps
| that computers can follow within some constraints, thus forming
| a solution to the original problem. The second is expressing
| the solution in a way that the computer can understand.
|
| Both parts provide the programmers with an infinite canvas on
| which they can express their creativity. There are practically
| limitless ways to approach and solve a problem, and a
| practically infinite way to express a solution to the problem.
| Hence, programming is a form of self-expression - it is an art
| form. What is produced through programming is a kind of art -
| an art few appreciate.
|
| ## I am a programming artist
|
| In that sense, I see myself as an artist, one that expresses
| his creative self through programming. I enjoy creating
| programming art, because only through it do I find my true
| self, one who has a burning passion to create and build things.
|
| ## LLM is not for me
|
| Using LLM to write code is like asking an artist to paint for
| you. If you only want the end result, by all means! If you are
| like me who enjoy the process of painting, then why would you
| bother automating the fun part away? One may say, "But I am
| only using LLM to write code. I am still doing the problem
| solving myself!". To me, programming isn't complete if I don't
| get to express the solution in code myself. It isn't my art if
| I don't create it myself.
|
| ## A sad reality
|
| It is sad to me just how much people are trying to automate
| away programming and delegating it to a black box that can't
| even count letters in a word sometimes. They are even going as
| far as trying to emulate a software engineer on top of the
| black box. Does no one not find programming fun anymore? Does
| no one care enough about programming to go further beyond
| getting things working "well enough"? Is this just another case
| of availability bias?
|
| Please don't take this as a judgmental piece to anyone that I
| am alluding to. It's fine to not find programming enjoyable.
| It's fine to just want things to work. I am just disappointed
| at how the ones who care appear to be an ever dying breed.
| latexr wrote:
| > Having sentences not start with uppercase letters really
| makes it one big mesh of letters.
|
| That annoying trend is infecting HN too. There's at least a
| half-dozen comments like that on this thread alone.
| creesch wrote:
| I really don't get what people think they are getting out of
| it though. Other than aesthetic "vibes".
| TrackerFF wrote:
| I used to work as a programmer, but have since pivoted into
| analysis - so I just view programming as another tool in my
| toolbox to solve problems. My main goal is to deliver insights
| and answer questions.
|
| Sad to say, LLMs have made me lazy coder for the past two years
| or so. But I do deliver/finish work much faster, so my incentives
| to keep using LLMs as coding co-pilots are overshadowing my
| incentives to write code the "old way".
|
| And for what it is worth, sometimes these posts read like modern
| luddite confessions - the rants just sound too personal.
| danjl wrote:
| English, and other languages, are vague and imprecise. I've never
| understood why folks think they can write code "more efficiently"
| with a prompt rather than code? Are people willing to give up
| control? Let the LLM decide what is best? The same is true for
| generative art -- you get something, but you only have marginal
| control over what. I think this will always be something that is
| useful for the simplest things, simplest apps, simplest art,
| etc.. A race to the bottom for the bottom of the complexity
| stack. As problems become more complicated, it would take a great
| deal more prompt language to specify the behavior than code.
| prisenco wrote:
| I wonder about this as well. Go has 26 keywords. English as
| _170,000_ active words.
|
| I don't want to code in English.
| BeetleB wrote:
| Binary has only two bits. I _really_ don 't want to code in
| two bits.
| throwup238 wrote:
| For most things I approach it from both sides: I give an
| English prompt but also provide some interface, function
| signatures, or even just a return type that constrains the LLMs
| output.
|
| For example, I frequently have to implement Serde's traits for
| some serialization format or to marshal types, most recently to
| translate types from Rust to Qt QML's Javascript. By giving it
| some context (Serde traits and QT docs) I managed to do it with
| Claude in about an hour, which is roughly how long it would
| have taken me just to get up to date with the documentation if
| I had tried it myself.
| kmoser wrote:
| Nobody in their right mind gives up control or lets the LLM
| decide what's best. They take the output of the LLM as a
| starting point, changing it where necessary to accomplish their
| goals.
|
| This is no different than starting with boilerplate code, e.g.
| from a tutorial or manual or other project (or, heaven forbid,
| an Internet search), and changing it for your specific needs.
|
| As for imprecision, a developer is perfectly capable of writing
| imprecise, ambiguous, or just plain buggy code by themselves.
| If you think your code is better than that produced by an LLM
| (and I'm not saying it isn't), then by all means use it. But
| the fact is that an LLM, in some cases, can produce code better
| and/or faster than it would take some people to write
| themselves who don't want to spend several minutes or hours
| stumbling through finding the exact syntax or algorithm, let
| alone Googling for a good starting point.
|
| As for the non-determinism that many people are decrying, this
| is no different from Googling and finding several examples,
| each of which is written for a particular use case, none of
| which ever seem to match yours exactly. Caveat emptor if you
| simply cut and paste without reading, just as with code
| produced by an LLM.
| danjl wrote:
| As I said, the LLM will be a good replacement for the
| simplest cases. The behaviors you describe are far more
| common among junior programmers working on simple apps.
| BeetleB wrote:
| > The behaviors you describe are far more common among
| junior programmers working on simple apps.
|
| Or among expert programmers who need to code in something
| out of their domain for a small portion of their job.
|
| Suppose you suddenly are required to write a VBA macro for
| Excel for your job. It's a one off task - not something
| you'll do repeatedly. Do you prefer learning VBA for Excel
| and crafting a solution or asking the LLM and verifying
| it's solution by looking at the docs?
|
| Hint: If you use the macro recorder in Excel and inspect
| the code you are closer to the LLM end of the spectrum.
| fuzztester wrote:
| this is one of the most perspicacious comments I have ever
| read about llms, with the disclaimer that i have not read a
| large number of comments on the subject. I have read some
| however.
|
| however, referring to the first paragraph of the comment
| above, the problem is that many people are not in their right
| minds :)
| TrianguloY wrote:
| I feel the same. I understand why others think ai is just another
| tool like intellisense, but for me intellisense and any other
| automatic refactor is a fixed algorithm that I understand and
| that I know exactly what it is doing, and I know that it is
| correct.
|
| With ai I need to review the output but not because there may be
| some issues I didn't noticed, but because that may be issues the
| tool itself didn't noticed, so it's less of an "apply this
| specific change" but more of an "apply some change"
| danjl wrote:
| With intelliSense, I disregard about 98% of the suggestions. Do
| people do that with generated code? Doubtful. With an LLM, even
| that last 2% requires more effort because it creates weird and
| irrational bugs that I have to review.
| namrog84 wrote:
| Lots of people I know use llms for different reasons and more
| importantly in different ways.
|
| For me it feels like it enables me to express myself even better.
| I use 1 for basically a super charged intellisense or clever auto
| complete. Finishing lines as I am typing them. Exactly the way I
| was going to write them.
|
| It saves time on the more boiler plate glue code and allows me to
| maintain a better flow and momentum on more expressive areas.
|
| I don't see it taking away anything but only enabling me to do
| more, faster, and better. I'm not telling it to write full apps
| because it can't.
| brunooliv wrote:
| This is a post that just reads as if the author is still in the
| "honeymoon" stage of their career where programming is seen as
| this extremely liberating and highly creative endeavour that no
| other mortal can comprehend. I get the feeling and I was there
| too, but, writing code has always been a means to an end which is
| to deliver business value. Painting it as this almost abstract
| creative process is just... not true. While there are many ways
| to attack a given problem, the truth is once you factor in
| efficiency, correctness, requirements and the patterns your team
| uses then the search space of acceptable implementations reduces
| a lot. Learn a couple of design patterns, read a couple of blogs
| and chat with your team and that's all you need. Letting an LLM
| write down the correct and specific ideas you tell it to based on
| what I wrote earlier means your free time to do code reviews,
| attend important meetings, align on high level aspects and help
| your team members all which multiply the value you deliver only
| through code. Let LLMs automate the code writing so I can finally
| program in peace, I say!
| PUSH_AX wrote:
| This might be the most "zoomed in" take on programming I've ever
| read (where a zoomed out take understands that software usually
| just enables a business to do business). I almost thought it was
| satire.
|
| I feel like you have to drop this kind of thinking to get
| anywhere past intermediate, not to mention you become a nightmare
| to anyone who has even a touch of pragmatism about them.
| modevs wrote:
| The times when #codecrafters will be as valuable as gold
| coming... I would prefer to rock into this times.
| spaceman_2020 wrote:
| I would have agreed with you about other creative spaces being
| invaded by AI
|
| But not code
|
| The consumer never sees the code. To him, it makes no
| difference if there is pure elegance underneath the app or just
| garbled spaghetti
|
| The user can likely tell AI-generated images and articles. But
| he'd have zero clue if the website used AI generated code
| danjl wrote:
| This is true at any instant in time, but it fails miserably
| over time as support and feature enhancement becomes
| important. A poor design from an LLM that cannot be updated,
| fixed, maintained, and improved is an issue that affects
| customers.
| modevs wrote:
| The changes into industry definitely coming. But AI will
| affect not only programming. And handmade products will cost
| more than autogenerated ones.
|
| Programming started sucks before when companies started to
| orient on fast income and preferred pure quality templated
| projects over well-made efficient ones.
|
| This world changes. Many people have nothing to do and with
| AI amount of them will grow. It scare.
| tinyhouse wrote:
| Not sure where LLMs will be in 5 years, can only talk about today
| and make some guesses about the future.
|
| I use LLMs cause it takes care of the syntax and leaves me more
| time to think about the logic and how everything is connected
| together. LLMs still lack in the latter category.
|
| For one-off tasks, it's truly a time saver. In the future, I see
| people trying to do more complex stuff with chains of LLM calls
| (already happening but it's still a WIP). Break a complex task
| into sub-tasks, then solve them sequentially to achieve something
| non-trivial in the end. I'm a bit skeptical though - not so much
| because of my skepticism of LLMs in general but more about humans
| not being good at maintaining code bases they didn't write (often
| even with code that wrote). You cannot trust LLMs to also
| maintain the codebase. There's too much context about the life of
| the code, all the dependencies, and even business logic, that is
| missing.
| sweeter wrote:
| If LLMs were actually good for programming, I would consider it,
| but they just aren't. Especially when we are talking about
| "assistants" and stuff like that. I feel like I live in an
| alternate reality when it comes to the AI hype. I have to wonder
| if people are just that bad at programming or if they have a
| financial incentive here.
|
| There are a handful of cases where LLMs are useful, mainly
| because Google is horrifically bad at bringing up useful search
| results, it can help in that regard... or when you can't find the
| right words to describe a problem.
|
| What I would like to see out of an AI tool, is something that
| gobbles up the documentation to another programming tool or
| language, and spits it back out when it is relevant, or some
| context aware question and answers like "where in the code base
| does XYZ originate" or w/e. the difference is having a tool that
| assists _me_ VS having a tool spit out a bunch of garbage code.
| Its the difference between using a tool, and being _used by a
| tool_
| fuzztester wrote:
| >If LLMs were actually good for programming, I would consider
| it, but they just aren't. Especially when we are talking about
| "assistants" and stuff like that. I feel like I live in an
| alternate reality when it comes to the AI hype. I have to
| wonder if people are just that bad at programming or if they
| have a financial incentive here.
|
| solid points there.
|
| it is surely some of both reasons. for the bad programmers, it
| will be the former. for those invested in llms, it will be the
| latter, that is financial incentives - to the tune of billions
| or millions or close to millions, depending upon whether you
| are an investor in or founder of a top llm company, or are
| working in such a company, or in a non-top company. it's the
| next gold rush, obviously, after crypto and many others before.
| picks and shovels, anyone?
|
| and, more so for those for whom there are financial incentives,
| they will strenuously deny your statements, with all kinds of
| hand waving, expressions of outrage, ridicule, diversionary
| statements, etc.
|
| that's the way the world goes. not with a bang but a whimper.
| ;)
|
| sorry, t.s. eliot.
|
| https://en.m.wikipedia.org/wiki/The_Hollow_Men
| andybak wrote:
| I'm not sure whether I'm a "good programmer" or a "bad
| programmer" but sometimes I just want a problem to go way in
| the quickest way possible.
|
| I'm not always trying to create a timeless, perfect, jewel
| and there is a _limit_ to how much I want to follow every
| highway and byway needed to do stuff across several dozen
| languages, libraries, platforms and frameworks.
|
| Some days I'm just tired.
| Tiberium wrote:
| I'm curious about your experience - what specific LLMs and
| tools did you try? And what's your main programming language?
| norir wrote:
| > I have to wonder if people are just that bad at programming
| or if they have a financial incentive here.
|
| I have similar feelings to you, but I want to be careful about
| making assumptions. That being said, I see so many people
| making hyperbolic claims about the productivity gains of llms
| and a huge amount (though not all) of the time, they are doing
| low value work that betrays their inexperience and/or lack of
| ability.
|
| I have yet to see a good example of where an llm invented a
| novel solution to an important problem in programming. Until
| that happens -- and I'm not saying it won't -- I remain
| extremely skeptical about the grandiose claims. This is
| particularly true of the companies selling llm products who
| make vague claims about productivity benefits. Who is more
| productive, the person who solves the most leet code problems
| in a month or the person who implements a new compiler in the
| same time frame? The former will almost surely have the most
| lines of code, but they have done nothing of direct value. I
| point this out because of how often productivity is measured in
| lines of code and/or time to complete a problem with a known
| solution.
|
| So for me, when people brag about how much more productive they
| are with llms, I wonder, ok, well what are you building? I feel
| like llms are as likely going to make people build fragile
| bridges to nowhere at scale as anything truly revolutionary.
| creesch wrote:
| I am not expecting novel solutions from LLMs. I purely use
| them as a tool in my tool belt.
|
| Some examples:
|
| _Deciphering spaghetti code_ : LLMs generally are pretty
| good at picking apart code blocks and generally explaining
| the functional parts. A while ago I was dealing with code
| that had lots of methods on single lines with tons of
| conditions. I put in in chatGPT, asked it to go over it and
| it gave me a point by point explanation of all the logic in
| there. Again, I don't expect it to be perfect here, it
| doesn't need to be. The way my mind works once I have the
| explanation I can much easier go to the single line mess and
| follow it along. If chatGPT messed up I will see that, but I
| will also be much further along already with deciphering as I
| would have been doing it manually.
|
| _Getting a quick start on technology_ , specifically if it
| is something I know I will only need to know once it helps me
| avoid tedious google searches. Instead I get a pretty decent
| rundown of whatever it is I need to know as well as some
| basics.
|
| In short, I don't they are miraculous technologies
| transforming my work. But, they are pretty good at removing
| some of the more tedious tasks letting me focus on other
| things. So they do make me more productive in that aspect.
| Arn_Thor wrote:
| I know jack squat about programming. I could at one point do
| "hello world" in Python, if I recall correctly. Thanks to
| ChatGPT I now have scripts to make my life easier in a bunch of
| ways and a growing high-level understanding of how they work. I
| can't program, an I won't claim to. But I can be useful. Thanks
| to LLMs. (And before the catastrophists arrive: I know enough
| to be wary of the risks of running scripts I don't understand,
| which is why I make a point of understanding how they function
| before I proceed)
| BeetleB wrote:
| There's a large continuum between great and crap, and it sounds
| like you've placed a rather high bar to even consider using it.
|
| I don't like BASH scripting. I wanted to automate a certain
| task and dump it in a justfile for convenient reference.
|
| Learning BASH scripting would be a poor use of my time - I
| didn't value the knowledge I would gain.
|
| Using Google to piece together everything I needed would have
| been very painful. Painful enough that I simply didn't bother
| in the past.
|
| Asking an LLM solved the problem for me. It took about 6
| iterations, because I had somewhat underspecified and the
| scripts it returned, while correct, had side effects I didn't
| like.
|
| But even though it took several iterations it was infinitely
| more satisfying than the other options. Every time it failed I
| would explain to it what went wrong and it would amend the
| script.
|
| It's like having an employee do the work for me, but much much
| cheaper.
|
| That's the power of LLMs. They enable me to do things that just
| weren't worth the time in the past.
|
| Would I use it for my main programming work? No. But does it
| increase my productivity? Definitely.
| TrackerFF wrote:
| I'll counter you here.
|
| I'm starting to think that the people that moan the most about
| LLMs being terrible, might just be terrible at writing good
| queries.
|
| Like everything else: garbage in, garbage out.
|
| EDIT: I was not aiming this comment directly at you. But I've
| had a couple of devs try to convince me that tools like ChatGPT
| or Claude is garbage, and then use extremely short queries as
| proof.
|
| "Write me a website with [list of specs]", and then when it
| either fails or spits out half-baked results, they go "See?
| It's garbage!"
|
| On the other hand I've seen non-coders create usable tools, by
| breaking up the problem and inputting good queries for each of
| those sub-tasks.
| sbuttgereit wrote:
| I think the arguments in this article/blog/etc. aren't as strong
| as they ought to be to make the point the author tries to make.
|
| My formal education was in music composition and film scoring
| specifically. I never once, even then considered myself "an
| artist" or thought that I was pursuing art. I did consider myself
| a craftsman: I was learning a style of music composition where I
| was expected to realize someone else's vision for their purposes.
| One could argue that the filmmaker was an artist and the film a
| work of art, but as the composer my job was to produce a work
| product that conformed to a specification as directed by someone
| else. I cared about creativity, quality, and having my product
| fit for purpose. I do not see the craftsman as inferior to the
| artist, but the goals are different and in a medium such as film
| you must have both artists and craftsmen (and sure sometimes a
| single person is both, but that's not a requirement).
|
| When I am a programmer I see myself in exactly the same way.
| Professionally, I'm paid to satisfy someone else's need for
| automation/data wrangling. The solution I deliver is a work of
| craftsmanship, not of art. I will be creative in exercising my
| craft: often I'm just given a statement of the problem that needs
| solving and the solution design and development are left to me. I
| may find unique capabilities or processes which are better than
| those anyone envisioned... but at the end of the day I am
| creating an expression of my craft, not trying to achieve a
| deeper artistic goal. Trying to achieve an artistic goal with
| programming, at least in most professional programming, would
| likely lead to some sort of malpractice: the craft of the product
| diminished in time, cost, or features to gain an unasked for
| message.
|
| Another issue I take with this article is that it confuses the
| tools with the result. Today, artists that paint use a large
| variety of brushes, spatulas, and other tools and paints which
| have all the benefits of being formulated with the knowledge of
| modern chemistry for stability, texture, and durability over
| time. Would the artist of old be justified in suggesting that
| using the new tools make you not an artist since you don't have
| to control for the limitations of the past? As a composer, I used
| sample players, sequencers, notation programs, and DAWs, even
| when writing for a conventional orchestra. True Beethoven didn't
| have these tools, but does this mean a modern composer that might
| use the same tools as me don't produce art... even if the final
| result is played by a traditional orchestra? I find LLMs to be in
| this category. When producing art (or craft as I discussed), the
| final product is ultimately what is to be judged... unless you
| find programming as being more about performance art where the
| journey is more the product that the final result.
|
| Anyway, as a programmer I absolutely use LLMs. Sometimes they
| help, sometimes not. Even at my most creative, I don't find
| developing a good regex or a shell script something I care to be
| creative in approaching. How I apply the LLM, my judgement of the
| quality of what it produces, or whether I think the kind of
| "lowest common denominator" approach an LLM will produce is
| appropriate or not in a given situation still puts me and my
| creativity plainly at the center of producing a craft-full, and
| perhaps artful, product.
| benterix wrote:
| A while ago antirez offered an interesting counter-perspective
| that is probably a more pragmatic approach:
|
| https://news.ycombinator.com/item?id=38840626
| tarkin2 wrote:
| LLMs will become as evil as calculators: they obviate the
| mathematical ability and create reliance in most, but are a
| magnificent aide to experts--those who could survive without a
| calculator albeit at the cost of speed.
|
| As we approach this point, programming (program creation) will
| become a largely non-technical skill but the few who have that
| skill will be needed to solve the problems which LLMs create and
| which its operators don't have the know-how to fix.
|
| I use LLMs as an alternative to asking a question on
| stackoverflow. And I'm not confident LLMs can currently save time
| on large projects: take a couple of hours to write the code or
| spend a few seconds to generate the code and then a couple of
| hours understanding and debugging it.
| frje1400 wrote:
| LLM output can't really be trusted so I need to "proof read" it
| and convince myself that it is correct. In the language I use
| every day and have a high degree of fluency, it's faster for me
| to simply write what's in my head than to proof read unknown
| code. So how can LLMs make me more productive in actual
| programming?
|
| I use an LLM to generate ideas, to rubber duck, to get a lead on
| unknowns, and to generate boilerplate occasionally. So I do
| everything except replace the coding part because that's what
| requires the most precision, and LLMs are bad at precision. And
| yet, people claim massive productivity gains in specifically
| coding. What am I missing?
| danjl wrote:
| Also, the errors that an LLM makes are not errors that a
| typical human would make. This makes reviewing their code
| particularly challenging.
| BeetleB wrote:
| > So how can LLMs make me more productive in actual
| programming?
|
| Suppose you suddenly are required to write a VBA macro for
| Excel for your job. It's a one off task - not something you'll
| do repeatedly. Do you prefer learning VBA for Excel and
| crafting a solution or asking the LLM and verifying its
| solution by looking at the docs?
|
| Hint: If you use the macro recorder in Excel and inspect the
| code you are closer to the LLM end of the spectrum.
| spaceman_2020 wrote:
| This is such a strange hill to die on.
|
| Like what great ideological purpose are you serving if you
| delegate writing tailwind boilerplate to a LLM, or a basic axios
| get request?
|
| Does your code become impure if instead of copying code from the
| documentation you get an LLM to do it?
| matwood wrote:
| It does feel similar when I was younger, and people would say
| you weren't a 'real' programmer unless you coded in c/c++.
| furyofantares wrote:
| I also find programming extremely enjoyable, my means of
| expression, and an art form. I have hundreds of side projects in
| my archive, maybe five of which have ever been used by another
| human. It's all for the sake of coding. Many of them are sizeable
| and many are not but they are almost all done as a creative
| outlet, for the joy of doing it or to satisfy a curiosity.
|
| But I don't know man, I love coding with LLMs. It just opens up
| more things, I think on some projects I actually spend MORE time
| on traditional coding than I did in the past, because I used an
| LLM to write scripts to automate some tedious data processing
| required for the project. And there's also projects where the LLM
| gets me from 0 to 60 and then I rather quickly write the code I
| actually care about writing, and may or may not end up replacing
| all the LLM written code.
|
| I'm sure it heavily depends on exactly what types of project
| interest you. The fact that LLMs and diffusion have both become
| fixations of mine also means I have a lot more data processing
| involved in lots of my projects, and LLMs are quite good at
| custom data processing scripts.
|
| I suppose my suggestion to the author would be that perhaps their
| projects aren't amenable to LLMs in the way they want and that's
| fine, but don't lose hope that there are kindred spirits out
| there just because so many people love LLM coding; some of us are
| both and that may be more about what types of projects we do.
| ThrowawayTestr wrote:
| >I also find programming extremely enjoyable
|
| I that's a big gulf people don't appreciate. I don't enjoy
| programming. When I program a microcontroller for my hobby
| projects it's a means to an end. I would love a tool that takes
| in a natural language description of what I want and outputs
| code and LLMs are good at doing that for basic tasks.
| danjl wrote:
| Rather than writing the code for me, I would appreciate the LLM
| functioning as a pair programmer, making comments on the
| decisions I make as I write the code. Another case that would be
| extremely useful, but is basically impossible now, is to have the
| LLM write tests for my new code as I write the code. Of course
| understanding the test scaffold and what's important to test is
| way beyond the capability of current LLMs. I only write
| integration tests, and never unit tests. An LLM could probably
| code unit tests, but I feel that not particularly useful.
| However, I could see this becoming more useful than actually
| writing code in the long run.
| Bjorkbat wrote:
| I have a lot of different thoughts as to why using an LLM feels
| "off". One I've been thinking about as of late is that it feels
| flawed to measure productivity by code velocity, i.e. lines of
| code written per hour.
|
| Like, ideally, it shouldn't really take that much code to
| implement a thing. I like to think of programming as writing a
| bunch of levers, starting with simple levers for simple jobs,
| incrementally ratcheting up to larger levers lifting the smaller
| levels. Before too long, it'll feel as though you've written a
| lever capable of lifting the world...or at least one that makes
| an otherwise wickedly difficult project reasonably manageable.
|
| If you say that LLMs make you more productive because it allowed
| you to finish a project that would otherwise take forever to
| write, then I'm skeptical that an LLM is the best solution. I
| mean, it's a solution at least, but I can't help but wonder if
| there's a better solution.
|
| If the problem is that you lack the understanding to take on such
| a project, then perhaps what we really need are better tools for
| understanding. I myself have found that LLMs are great for
| gaining a quick understanding of languages that otherwise have
| sparse information for beginners, but I have to wonder if perhaps
| there's a better way.
|
| If, on the other hand, the problem is that writing that much code
| would take forever, then I have to wonder if the real solution is
| that we need a better way to turn programming languages into
| patterns (levers) and turn said patterns into larger patterns
| (larger levers)
|
| A partial solution works, but only partially well, and
| occasionally has consequences one has to reckon with
| brubs wrote:
| To be honest, I want an LLM to do my work, which means coding for
| me. But I won't quit coding as my hobby. I love to build and
| tackle challenges. I just hate the pressure of deadlines, boring
| coding tasks, spaghetti code from my team members, code style
| differences between me and others, and so on. Coding has turned
| into corporate stuff. I do it for a living, but I really don't
| like doing it with all these issues in the mix.
|
| I like to code in the middle of the night, solving very complex
| problems and building cool applications.
| DoesntMatter22 wrote:
| I love to program! I started in 1993 when I was 12 and I'm 42
| now. I've never lost my love for it. Been a workaholic most of my
| life because I just love to code. However... after using Claude
| 3.5 with Cursor I realize that it's over. I'm writing whole apps
| in a day, sophisticated ones, that would take me a couple of
| weeks before, and way more energy spent.
|
| I wrote a whole Slack clone (not feature complete of course) in
| just 1 day. I love to code, and I do have to at times but this
| feels like the end of what was the joy of my youth and adulthood,
| my favorite pastime is gone. I will still develop applications
| and enjoy my creativity but with probably 1/50th the effort it
| took before.
| geor9e wrote:
| I use an LLM precisely BECAUSE I want to focus on the art. Like
| Davinci would use apprentices.
|
| LLMs can do mindless drudgery just as well as I can, but in
| seconds instead of hours. There's nothing about remembering
| syntax, boilerplate code, forgetting a semicolon, googling the
| most common way of doing something, or combining some
| documentation to fill in the gaps that's even remotely "art" to
| me.
|
| I never ask an LLM for what I'm artfully creating. I ask it for
| what I know it'll get instantly right, so I can move on to my
| next thought.
| icambron wrote:
| To have all these thoughts, I think you'd have to have never
| really used an LLM to help you code, or to be almost comically
| closed-minded when you do. What they feel like when you actually
| use them is a combination of a better SO and a very prescient
| auto-completer. It does not at all feel like delegating
| programming work to a robot. No loss of artistry comes into play,
| and it's damn useful.
|
| In an ideal world, our abstractions would be so perfect that
| there would be no mundane boiler-platey parts of a program; you'd
| use the abstractions to construct software from a high level and
| leave details be. But our abstractions are very far from perfect:
| there's all kinds of boring code you just have to write because,
| well, your program has to work. And generally that code is, if
| you look, _most of your code_. This because making good
| abstractions is really hard and constructing fresh ones is often
| more work than just typing out the different cases. If you think
| this is mistaken, I 'd gently suggest you take a fresh look at
| your own code.
|
| Anyway, that's where LLMs come in. They help write the boring
| code. They're pretty good at it in some cases, and very bad at it
| in others. When they're good at it, it's because what the code
| should do is sort of overspecified; it's clear from context what,
| say, this function has to do to be correct, and the LLM is able
| to see and understand that context, and thus generate the right
| code to implement it. This code is boring because it is in some
| vague sense unnecessary; if it couldn't be otherwise, why do you
| have to write it at all? Well you do, and the LLM has taken care
| of it for you.
|
| You can call this work the LLM is displacing "art", but I
| wouldn't. It's more the detritus of art performed in a specific
| way, the manual process required to physically make the art given
| the tools available.
|
| You could object that the LLMs will get better in the sense that
| not only that they will make fewer mistakes, but they will be
| able to take on increased scope, pushing closer to what I'd
| consider the "real" decisions of a program. If this happens --
| and I hope it does -- then we should reevaluate our lofty
| opinions of ourselves as artists, or at least artists whose
| artistry is genuinely valuable.
| slowhadoken wrote:
| The argument against this is usually "oh yeah are you going to
| write your own compiler? Or better yet build your own CPU and
| motherboard?" but some people do because it's fun and
| educational. Ignorance isn't a valuable skill set.
| Kiro wrote:
| I'm of the opposite opinion: I've started enjoying programming
| much more after embracing LLMs.
|
| * They are great for overcoming procrastination. As soon as I
| don't feel like doing something or a task feels tedious I can
| just delegate it to an LLM. If it doesn't solve it outright it at
| least makes me overcome the initial feeling of dread for the
| task.
|
| * They give me better solutions than I initially had in mind.
| LLMs have no problem adding laborious safeguards against edge-
| cases that I either didn't think of or that I assessed wouldn't
| be worth it if I did it manually. E.g. something that is unlikely
| and would normally go to the backlog instead. I've found that my
| post-LLM code is much more robust from the get go.
|
| * They let me try out different approaches easily. They have no
| problem rewriting the whole solution using another paradigm,
| again and again. They are tireless.
|
| * They let me focus on the creative parts that I enjoy. This
| surprised me since I've always thought of myself as someone who
| loves programming but it turns out that it is only a small subset
| of programming I love. The rest I'm happy to delegate away.
| magicalhippo wrote:
| > This surprised me since I've always thought of myself as
| someone who loves programming but it turns out that it is only
| a small subset of programming I love.
|
| I am the same, and why many of my personal projects end up
| stranded. Once I've solved the tricky bit, the rest often isn't
| that motivating as it's usually variations on a common theme.
|
| I held off LLMs for a long time, but recently been playing with
| them. They can certainly confidently generate junk, but in most
| cases it's good enough. And like you say can be used as a
| driver to keep going. In that regard they can be useful.
| verditelabs wrote:
| Same, these are all great points that I find as well. LLMs have
| made me a way more productive programmer, but a lot of that is
| because I already was an alright programmer and know how to
| take advantage of the strengths and weaknesses of the LLM. I
| think your last bullet point is most poignant, using Claude 3.5
| I've been able to do tons of GUI and web programming, things I
| absolutely despise and refuse to do if I'm writing code by
| hand.
|
| I sort of understand some of the vitriol that I see on HN but
| it is incredibly overblown. I don't really get a lot of the
| criticisms. LLMs aren't deterministic? Neither are humans. LLMs
| write bugs they can't fix? So do humans. LLMs are only good at
| being junior programmer copy paste machines? So are lots of
| humans.
|
| My current project is training an LLM to do superoptimization
| and it's working exceedingly well so far. If you asked anyone
| on hacker news if that's a good idea, they'd probably say no.
| willtemperley wrote:
| This is exactly how I use LLMs - I can automate the really
| boring parts. "Can you write me a Swift codable struct for the
| following JSON" will save my fingers and precious mental energy
| for the important and interesting parts.
|
| It's like having a junior dev that doesn't complain and gets
| the work done immediately.
|
| AI code suggestions as I type are however a different beast.
| It's easy to introduce subtle bugs when the suggestion "kinda
| looks right" but in fact the LLM had zero understanding of the
| context because it can't read my mind.
| mr_tristan wrote:
| I don't use an LLM largely because my current codebase has a
| _massive_ amount of bespoke internal APIs. So LLMs are just
| useless and wrong for almost any task I use.
|
| But this has led me to wonder if there will be gradual pressure
| to build on top of LLMs, which, in turn, will really only be
| useful with the tried and true. Like, we're going to be heading
| towards an era where innovation means "we can ask the LLM about
| it". Given the high capital costs required to train, I wouldn't
| be shocked to see LLMs ignoring new unique approaches and biasing
| to whatever the big corps want you to do. For "accuracy".
|
| I just sense were about to hit an era of software causing massive
| problems and costs, because LLMs are rapidly accelerating the
| pace of accidental complexity, and nobody knows really how to
| make money off them yet.
| layer8 wrote:
| Exactly my thoughts. It might even work reasonably well in the
| end, but it seems it would make the world of computing a much
| less fun place.
| pmarreck wrote:
| If we're going to have LLM's writing code that we depend on, then
| we for damn well sure better have both typechecking and unit
| tests also in place. Hell, make it do TDD since humans don't seem
| very keen on that despite its empirical advantages
| nprateem wrote:
| Lol, this won't age well.
|
| BTW what's the aider vs cursor opinion?
| alexpc201 wrote:
| "LLM is not for me" sounds right. But, if you want to use LLM to
| avoid building the tedious parts of a project like the user
| interface, APIs, etc., and decide to code your algorithms the
| old-fashioned way, that's fine too.
| layer8 wrote:
| This article has me wishing for a Reader Mode implementation that
| auto-uppercases sentences.
| cbare wrote:
| I also view coding as essentially creative.
|
| Programming was mostly a hobby in the days of 8-bit PCs. It was a
| profession for some decades. Maybe it will be a hobby again in 5
| years. Like gardening, sailing, fishing - professions at one
| time, now hobbies.
|
| On the other hand, the arrival of futuristic capabilities like
| computers speaking human languages is what drew me to technology
| in the first place. Luckily, you can choose to look forward and
| backward. You don't have to pick only one.
| DiscourseFan wrote:
| Meanwhile I don't use webhosted LLMs because I don't want them
| sucking up my work!
| ein0p wrote:
| You're not automating the "art" with llms. You're automating
| stretching the canvas and squeezing out the paint. LLMs by design
| can't create anything fundamentally new. Which is the "art" part
| of the whole exercise.
| yakshaving_jgt wrote:
| I don't do _programming as art_. I just want to see the result.
|
| That said, in my experience, trying to get ChatGPT to spit out
| sensible code is sometimes like arguing with a conspiracy
| theorist. I ask a question, receive an answer, ask a follow-up
| question and scrutinise one of the details, and the interviewee
| just falls apart and grasps for other straws.
| nerder92 wrote:
| Programming is not art, problem solving is.
|
| Programming is just a mean to an end, please stop this cringe
| romantic rhetoric. If you really love programming you don't care
| about the medium, the fact that a program is represented as text
| is just a transient phase in the history due to the current tech
| we have available in this specific moment in time. Programming
| (today) is expressed as text, LLMs auto complete boring text, so
| that us "the artists" can write more of it faster, end of story.
___________________________________________________________________
(page generated 2024-08-25 23:01 UTC)