TFA's while point is that there is no easy way to tell if LLM output is correct or not. Driving mistakes provide instant feedback if the output of whatever AI is driving is correct or not. Bad comparison.
Many of the things that LLMs will output can be validated in a feedback loop, e.g., programming. It's easy to validate the generated code with a compiler, unit tests, etc. LLMs will excel in processes that can provide a validating feedback loop.
I love how everyone thinks software is easy to validate now. Like seriously, do you have any awareness at all about how much is invested in testing software by the likes of Microsoft, the game studios, and any other serious producers of software? It's a lot, and they still release buggy code.
No, that's not it. The difference between humans and AI is that AI suffers no embarrassment or shame when it makes mistakes, and the humans enthusiastically using AI don't seem to either. Most humans experience a quick and viseral deterrent when they publish sloppy code and mistakes are discovered. AI, not at all. It does not immediately learn from its mistakes like most humans do.
In the rare case when there is a human that is consistently persistently confidently wrong like AI, a project can identify that person and easily stop wasting their time working with that person. With masses of people being told by the vocal AI shills how amazing AI is, projects can easily be flooded with confidently wrong aaI generated PRs.
There is a catch though, you need to download and install Termux & Emacs from this project as per the instructions. It took me a while to get it working, but after that it worked like a charm.
Termux isn't required, unless you want other applications (e.g. git, python, or GCC).
If you do want Termux, a signed and compatible version is provided by the Emacs devs. It should all be in the README (at least it always has been, through various updates, since I started using the Emacs on Android before it was merged into the main branch).
There is no life without pain and suffering. It's as much a law of nature as gravity. Life needs something to push against, to struggle to overcome. Without that there simply is no life. If life doesn't struggle and suffer against things it never even starts. Once started, if life stops struggling and suffering, it quickly dies.
Religion and tradition have elevated humanity and it's good to acknowledge that. They never could have eliminated suffering, only changed the sources and types of suffering. It is helpful for many of us to have things like religion and traditions to give the suffering more meaning, sense, and purpose.
Writing, journaling, is such a good way to process thoughts and emotions and this is a great example. I'm grateful for this person sharing her very personal journal entries with us even though it is not required at all. It sets a great example of what to write about and how. It also reveals that people and the lives they live are incredibly complicated and messy. The longer I live and the more people I get to know the more I believe that nobody is as simple and "good" as they seem on the surface. If your life has been simple and relatively pain free up to this point, just wait, and try not to judge others in situations more difficult and complicated than yours too harshly. There is much you do not yet know.
And it hasn't worked in practice. C unfortunately does not have a very big pit of success -- it's way too hard to do the right thing and way too easy to do the wrong thing.
The solution to this doesn't have to be "rewrite everything in Rust", but it does mean that you need to provide safe, easy implementations for commonly-screwed-up patterns. Then you're not asking people to be perfect C programmers; you're just asking them to use tools that are easier than doing the wrong thing.
> "ask the developers to practice discipline" is a baseline requirement for coding in C
Sure, but since there's 10x more opaque footguns in C+++, there is much less discipline needed than when coding in C++.
The footguns in C are basically signed-integer over/underflows and memory errors. The footguns in C++ include all the footguns in C, and then add a ton more around object construction type, object destruction types, unexpected sharing of values due to silent and unexpected assignments, etc.
Just the bit on file-scope/global-scope initialisation alone can bite even experienced developers who are adding a new nonlocally-scoped instance of a new class.
Not sure why this is down voted when the whole point of TFA is to torture the C language into doing something it can't really do. I guess there's an unspoken assumption in TFA that you are stuck using C and absolutely cannot use a different language, not even C++?
This looks far less tortured to my eye than C++. I think a lot of us have this self-imposed rule, for whatever reason, that we absolutely will not use C++.
