It can't do things with me like a human, it's not human, it's not intelligent, it's not thinking, it's not aware. It's an aide I use, not a tool I rely on.
I mean -also- weird to claim that the CCP invented scoring folks, but even if they did, it'd be hella weird to think that somehow they helped a US local power company implement it...
Look, I get that "CCP Bad". It's just always wild to see folks try and make that case when something has literally nothing to do with it, especially while there are plenty of pretty horrific and material mechanisms in play without pretending that the big-O Other is to blame.
I guess the point is: How often do we really need actual angles in the code? Probably only at the very ends: input from users and output to users. Everywhere else, we should just be treating them as sin/cos pairs or dot/cross pairs. So when the user inputs an angle, immediately convert it to what the computer actually needs, store it that way throughout the computation, and then only if/when the user needs to see an actual angle would you need to convert it back.
Same for me, has been my whole life. I complain about it all the time. It's well documented that people can read black on light far better and with less eye strain than light on black; yet there seems to be a whole generation of developers determined to force us all to try and read it. Even the media sites like Netflix, Prime, etc. force it. At least Tubi's is somewhat more readable.
Sometimes a site will include a button or other UI element to choose a light theme but I find it odd that so many sites which are presumed to be designed by technically competent people, completely ignore accessibility concerns.
The most common mistake I see (on this website at least) is the assumption that one's programming competence is equal to their competence in other things.
1. You are right that we can redefine what is code. If code is the central artefact that humans are dealing with to tell machines and other humans how the system works, then CodeSpeak specs will become code, and CodeSpeak will be a compiler. This is why I often refer to CodeSpeak as a next-level programming language.
2. I don't think being deterministic per se is what matters. Being predictable certainly does. Human engineers are not deterministic yet people pay them a lot of money and use their work all the time.
>Human engineers are not deterministic yet people pay them
Human carpenters are not deterministic yet they won't use a machine saw that goes off line even 1% of the time. The whole history of tools, including software, is one of trying to make the thing do more precisely what is intended, whether the intent is right or not.
Can you imagine some machine tool maker making something faulty and then saying, "Well hey, humans aren't deterministic."
Compiler is not 100% deterministic. Its output can change when you upgrade its version, its output can change when you change optimization options. Using profile-guided optimization can also change between runs.
If you change inputs then obviously you will get a different output. Crucially using the same inputs, however, produces the same output. So compilers are actually deterministic.
This is irrelevant over the long run because the environment changes even if nothing else does. A compiler from the 1980's still produces identical output given the original source code if you can run it. Some form of virtualization might be in order, but the environment is still changing while the deterministic subset shrinks.
Having faith that determinism will last forever is foolish. You have to upgrade at some point, and you will run into problems. New bugs, incompatibilities, workflow changes, whatever the case will make the determinism property moot.
Many compilers aren't deterministic. That's why the effort to make Linux distros have reproducible builds took so long and so much effort.
The reason is, it's often more work to be deterministic than not deterministic, so compilers don't do it. For example, they may compile functions in parallel and append them to the output in the order they complete.
> yet I don't have to know or care about implementation details
Where do I even begin...yes, you should care about implementation details unless you're only going to write stuff you run locally for your own amusement.
until you learn to trust the system and free mental capacity for more useful thinking. at some point compilers became better at assembly instructions than humans. seems inevitable this will happen here. caring about the details and knowing the details are two different things.
I've had the LLM "lie" to me about the code it wrote many times. But "lie" and "hallucinate" are incorrect anthropomorphisms commonly used to describe LLM output. The more appropriate term would be garbage.
Just a basic sanity check: did the LLM have the tools to check its output for lies, hallucinations and garbage? Could it compile, run tests, linters etc and still managed to produce something that doesn't work?
I've frankly given up on LLMs for most programming tasks. It takes just as much time (if not more) to coddle it to produce anything useful, with the addition of frustration, and I could have just written far better code myself in the time it takes to get the LLM to produce anything useful. I already have 40 years experience programming, so I don't really need a tin-can to do it for me. YMMV.
Compilers are deterministic tools. AI is not deterministic. It will tell you this if you ask it. AI then, is not a tool. It is an aide. It is not a tool like a compiler, IDE, editor, etc.
It may have reduced the time to an implementation, based on my experiences I sincerely doubt the veracity of applying the adjective "working".
reply