3 ms·

AI is just another layer of abstraction. I'm sure the assembly language folks were grumbling about functions as being too abstracted at one point

pavel_lishin 6mo ago
You could say that about atomic bombs, too.
kmaitreys 6mo ago
High level languages that replaced assembly are not black boxes.
- deleted 6mo ago
  [deleted]
- kaoD 6mo ago
  And they're as deterministic as as the underlying thing they're abstracting... which is kinda what makes an abstraction an abstraction. I get that people love saying LLMs are just compilers from human language to $OUTPUT_FORMAT but... they simply are not except in a stretchy metaphorical sense. That's only true if you reduce the definition of "compiler" to a narrow `f = In -> Out`. But that is _not_ a compiler. We have a word for that: function. And in LLM's case an impure one.
makerofthings 6mo ago
I totally see what you're saying, but to me this feels different. Compilation is a fairly mechanical and well understood process. The large language models aren't just compiling English to assembler via your chosen language, they try and guess what you want, they add extra bits you didn't ask for, they're doing some of your solution thinking for you. That feels like more than just abstraction to me.
- seanosaur 6mo ago
  I think it's still abstraction by definition, but you're right in that it's a much larger single leap than in the past.
  - kaoD 6mo ago
    > it's still abstraction by definition I dislike arguing semantics but I bet it's not an abstraction by most engineers' definition of the word.
  - acedTrex 6mo ago
    If this is true then a PMs jira tickets are an abstraction over an engineers code. It's not necessarily wrong by some interpretations but is not how the majority of engineers would define the word.
jncfhnb 6mo ago
That is abstraction of the implementation of the tool, not the output. Producing outputs you don’t understand is novel
seattle_spring 6mo ago
Higher level languages that abstract assembly code are deterministic. AI, on the other hand, is not.
beart 6mo ago
AI is non-deterministic. Can it still be considered an abstraction over a deterministic layer?
- whattheheckheck 6mo ago
  It can loop and probabilistically converge to a set of standards verified against a standard set of eval inputs
- kypro 6mo ago
  The argument against this is that human coders are also non-deterministic, so does it really matter if it's a human or an AI agent producing the code – assuming the AI agent is capable of producing human-quality code or better? I agree it's not a layer of abstraction in the traditional sense though. AI isn't an abstraction of existing code, it's a new way to produce code. It's an "abstraction layer" in the same way an IDE is is an abstraction layer.
  - bluefirebrand 6mo ago
    > The argument against this is that human coders are also non-deterministic, so does it really matter if it's a human or an AI agent producing the code Actually yes, because Humans can be held accountable for the code they produce Holding humans accountable for code that LLMs produce would be entirely unreasonable And no, shifting the full burden of responsibility to the human reviewing the LLM output is not reasonable either Edit: I'm of the opinion that businesses are going to start trying to use LLMs as accountability sinks. It's no different than the driver who blames Google Maps when they drive into a river following its directions. Humans love to blame their tools.
    - bit-anarchist 6mo ago
      > Holding humans accountable for code that LLMs produce would be entirely unreasonable Why? LLMs have no will nor agency of their own, they can only generate code when triggered. This means that either nature triggered them, or people did. So there isn't a need to shift burdens around, it's already on the user, or, depending on the case, whoever forced such user to use LLMs.
mananaysiempre 6mo ago
> AI is just another layer of abstraction. A fundamentally unreliable one: even an AI system that is entirely correctly implemented as far as any human can see can yield wrong answers and nobody can tell why. That’s not entirely the fault of the technology, as natural language just doesn’t make for reliable specs, especially in inexperienced hands, so in a sense we finally got the natural-language that some among our ancestors dreamed of and it turned out to be as unreliable as some others of our ancestors said all along. It partly is the fault of the technology, however, because while you can level all the same complaints against a human programmer, a (motivated) human will generally be much better at learning from their mistakes than the current generation of LLM-based systems. (This even if we ignore other issues, such as the fact that it leaves everybody entirely reliant on the continued support and willingness to transact of a handful of vendors in a market with a very high barrier to entry.)

pavel_lishin 6mo ago

You could say that about atomic bombs, too.

kmaitreys 6mo ago

High level languages that replaced assembly are not black boxes.

deleted 6mo ago
[deleted]
kaoD 6mo ago
And they're as deterministic as as the underlying thing they're abstracting... which is kinda what makes an abstraction an abstraction. I get that people love saying LLMs are just compilers from human language to $OUTPUT_FORMAT but... they simply are not except in a stretchy metaphorical sense. That's only true if you reduce the definition of "compiler" to a narrow `f = In -> Out`. But that is _not_ a compiler. We have a word for that: function. And in LLM's case an impure one.

makerofthings 6mo ago

I totally see what you're saying, but to me this feels different. Compilation is a fairly mechanical and well understood process. The large language models aren't just compiling English to assembler via your chosen language, they try and guess what you want, they add extra bits you didn't ask for, they're doing some of your solution thinking for you. That feels like more than just abstraction to me.

seanosaur 6mo ago
I think it's still abstraction by definition, but you're right in that it's a much larger single leap than in the past.
- kaoD 6mo ago
  > it's still abstraction by definition I dislike arguing semantics but I bet it's not an abstraction by most engineers' definition of the word.
- acedTrex 6mo ago
  If this is true then a PMs jira tickets are an abstraction over an engineers code. It's not necessarily wrong by some interpretations but is not how the majority of engineers would define the word.

jncfhnb 6mo ago

That is abstraction of the implementation of the tool, not the output. Producing outputs you don’t understand is novel

seattle_spring 6mo ago

Higher level languages that abstract assembly code are deterministic. AI, on the other hand, is not.

beart 6mo ago

AI is non-deterministic. Can it still be considered an abstraction over a deterministic layer?

whattheheckheck 6mo ago
It can loop and probabilistically converge to a set of standards verified against a standard set of eval inputs
kypro 6mo ago
The argument against this is that human coders are also non-deterministic, so does it really matter if it's a human or an AI agent producing the code – assuming the AI agent is capable of producing human-quality code or better? I agree it's not a layer of abstraction in the traditional sense though. AI isn't an abstraction of existing code, it's a new way to produce code. It's an "abstraction layer" in the same way an IDE is is an abstraction layer.
- bluefirebrand 6mo ago
  > The argument against this is that human coders are also non-deterministic, so does it really matter if it's a human or an AI agent producing the code Actually yes, because Humans can be held accountable for the code they produce Holding humans accountable for code that LLMs produce would be entirely unreasonable And no, shifting the full burden of responsibility to the human reviewing the LLM output is not reasonable either Edit: I'm of the opinion that businesses are going to start trying to use LLMs as accountability sinks. It's no different than the driver who blames Google Maps when they drive into a river following its directions. Humans love to blame their tools.
  - bit-anarchist 6mo ago
    > Holding humans accountable for code that LLMs produce would be entirely unreasonable Why? LLMs have no will nor agency of their own, they can only generate code when triggered. This means that either nature triggered them, or people did. So there isn't a need to shift burdens around, it's already on the user, or, depending on the case, whoever forced such user to use LLMs.

mananaysiempre 6mo ago

> AI is just another layer of abstraction. A fundamentally unreliable one: even an AI system that is entirely correctly implemented as far as any human can see can yield wrong answers and nobody can tell why. That’s not entirely the fault of the technology, as natural language just doesn’t make for reliable specs, especially in inexperienced hands, so in a sense we finally got the natural-language that some among our ancestors dreamed of and it turned out to be as unreliable as some others of our ancestors said all along. It partly is the fault of the technology, however, because while you can level all the same complaints against a human programmer, a (motivated) human will generally be much better at learning from their mistakes than the current generation of LLM-based systems. (This even if we ignore other issues, such as the fact that it leaves everybody entirely reliant on the continued support and willingness to transact of a handful of vendors in a market with a very high barrier to entry.)