xigoi
Born on July 02, 2020•4047 Karma
Okay, so you don't trust LLM, so you go to a website instead. And... LLM-generated pages are SEO'd to get the top links. So you can't trust any website now (shoot, so much nonsense even before LLM, just more obvious to some of us). So basically everything on a computer is untrustworthy, directly from an LLM or not, unless you got yourself a copy of Encarta '97.
So you pick up a book at the local library. Librarians picked some books to order in subject matters they aren't expert in. How do you know those are accurate and safe? If the book says to use rice starch glue, how do you know the author didn't just copy that from an LLM? Or make it up?
Trust is fading entirely.
The thing is, these things do produce some kind of result that looks like what you want. But it is still up to you to test these things on a project before you rely on them for whatever it is you really wanted them for, and that requirement doesn't go away just because you sourced the information from some LLM, or a book at the library, or Nick Offerman, or whoever else.
The computer generated recipes can be useful as inspiration, but of course common sense is required.
"On two occasions, I have been asked [by members of Parliament], 'Pray, Mr. Babbage, if you put into the machine wrong figures, will the right answers come out?' I am not able to rightly apprehend the kind of confusion of ideas that could provoke such a question."
~ Charles Babbage
And in C#, you can just type `await` and call an async function from a sync function.
Calling unsafe requires an unsafe block from safe functions. That's essentially the same thing as async/await in many languages (Rust does things differently, of course, but that's even worse in my opinion).
Yes, but not in JavaScript.
And what’s worse, many other languages copied this decision without understanding why it was made and why it’s completely nonsensical for modern languages.
(They use @ for marking keywords)
Operator overloading increases consistency. Instead of having
int a = b + c;
CustomNumberType x = y.add(z);
int a = b + c;
CustomNumberType x = y + z;But not having operator overloading when dealing with vectors is maddening.
Person x;
Job y;
CustomType z = x + y;
Is the argument, anyway, I support operator overloading.
Hopefully a type error, because no sane programmer would implement addition like this. Obviously an insane programmer could, but that’s not the fault of operator overloading. The following code is exactly as confusing:
Person x;
Job y;
CustomType z = add(x, y);Take a person, add a job, you get an Employee or EmployedPerson. Person.add(job).
I agree overloading can create footguns, but domain concepts should make a lot of sense in context when basic arithmetic operations are performed on them. Party = Meeting + Booze.
Custom operators are a big assistance for DSLs, and overloading can also aide their creation and elegance. Part of the “awesome but don’t be a jerk about it” toolbox.