And the same people who are complaining about time wasting of having to ask/answer a question from a coworker which might create a modicum of civility and connection in this bitter cruel world are the same shit-posting on social media and doom watching youtube all day. "My flow can't be interrupted, I need all my energy to refactor this column from VARCHAR to TEXT, and to update this button from onClick inline to using a named closure".

Please, the reality is that we sold human connection for an illusion of productivity and the bitter pill of isolation where we all now feel guilt and shame for wanting to talk with other people (through an albeit disconnected and disembodied asynchronous channel).

If anyone responds with "I don't have time to respond I'm so busy", please realize you are proving my point. You are literally doom scrolling YC for no reason and alienating / pushing away coworkers to argue with internet strangers, sad.

His point was that for his programming, he wants to be able to make real pointers and real linked lists with memory unsafe, which Rust makes difficult or opaque. For example with linked list, you could simulate (to avoid unsafe), by either boxing everything (so all refs are actually smart pointers), or you can use a container with scoped memory lifetime, and have integers in an array that are the "next" pointer. In addition to extra complexity, the "integers as edges" doesn't actually solve the complexity, it just means you can't get a bad memory error (you can still have 'pointers' that point to the wrong index if you're rolling your own).

Same with your graph code. Using a COO representation for a graph does in theory make it "memory safe" (albeit more clumsy to use if you are doing pointer-following logic), and it also introduces other subtle bugs if your logic is wrong (e.g. you have edge 100 but actually those nodes were removed, so now you're pointing at the wrong node).

I think the point (which I agree with for things like linked list, graph, compiler) is that depending on your usecase, the "safety" guarantees of rust are just making it harder to write the simplest most understandable code. Now instead of: `Node* next` I have lifetimes, integer references, two collections (nodes and edges) to keep in sync, smart pointers, etc. Previously my complexity was to make sure `next != null`, now its a ton of boilerplate and abstractions, performance hits, or more subtle bugs (like 'next' indices getting out of sync with the array of 'nodes').

If there was a way to explicitly track the lifetime of an arbitrary graph/tree of pointers at compile time, we wouldn't need garbage collection -- its not solvable at compile time, and the complexity has to live somewhere.

We're told its better than people at selecting songs (e.g. has the combined wisdom of all music and music experts), basic requests like "play the first movement of Beethoven's 7th" don't sound hard for an average person with limited / no musical expertise. If I said "please play the entire 7th symphony", and the tool responds with "sure, I'll play the whole thing", then proceeds to play the Beatles, I'd say that's a fair thing to point out as a shortcoming.

Its only obvious to tech people that understand that the technology has extreme limits and only works well on areas with abundant high quality data and labels, and can't be expected to reason like a person at all in many cases, that those limits seem as obvious as hammer / screw-driver. And that given how spotify developed these models, they probably didn't really intend classical or test that area -- so it fails despite sounding confident.

But maybe we should stop advertising screwdrivers as universal intelligence? There's a lot of mott and bailey going on. When AI makes mistakes its "just tools, stop expecting intelligence." However, when people question the AI hype its "humans make mistakes too, LLMs are truly reasoning and better most humans already." And "the entire labor economy will be replaced, human DJs will cease to exist.".

Same for self-driving. Just hold each car like a normal driver, the owning AI company has liability. So after ~20 tickets and accidents in a week, a few ambulances being blocked, the only option is to revoke the driver's license (of which, all the cars share one, as they have the same brain).

This would make AI companies more cautious and only advertise capabilities they actually have and can verify. They would be held to the standard of a human. I think that's reasonable (why replace humans if the outcome is worse, and why reduce protections for individuals).

To make the analogy more clear: even if a telemedicine doc sees 10,000 patients a day all over the world, they would be held liable for any medical malpractice. Bad enough, and their license would be revoked, regardless of the fact that they see many patients all over the world. Same deal with AI / LLM -- if ChatGPT is making medical advice and it hurts someone, that's the same as a human doing so -- its malpractice and lawsuits can happen.

If they are somehow licensed, well then that license can be revoked. We would revoke a human's license for a single offense in some cases, the same should occur with AI.

The fundamental difference is that physical neurons have a discrete on/off activation, while digital "neurons" in a network are merely continuous differentiable operations. They also don't have a notion of "spike timining dependency" to avoid overwriting activations that weren't related to an outcome. There are things like reward-decay over time, but this applies to the signal at a very coarse level, updates are still scattered to almost the entire system with every training example.

Its a bit like choosing JS / python -- of course performance is inferior to a compiled language with highly tailored code, but they are flexible and have an ecosystem that might do 99% of the lifting for you.

But in isolation, I agree with your idea that specialized robots with form fitted specifically to task will likely outperform a more generalized solution in a specific domain of behavior, the more generalized will likely outperform in flexibility and reusability (e.g. capable of reusing the human ecosystem).

All it really takes to do some kind of crazy world-dominating thing is some simple mechanisms and base intelligence, which the machines already possess. Using basic tactics like coercion, spoofing, threats, financial leverage, an unsophisticated attacker could cause major damage.

For example, that Meta exec who had their email deleted. Imagine instead one email had a malicious prompt which the bot obeyed. That prompt simply emailed everyone in her contacts list telling them to do something urgently (and possibly prompting other bots who are reading those emails). You could pretty quickly do something like cause a market crash, a nationwide panic, or maybe even an international conflict with no "super intelligence" needed, just human negligence, short-sightedness, and laziness.

Examples would be things like saying there is a threat incoming, a CIA source said so. Another would be that everyone will be fired, Meta is going bankrupt, etc. Its very easy to craft a prompt like that and fire it off to all the execs you can find (or just fire off random emails with plausible sounding emails). Then you just need to hit one and might set off a cascade.

Like the executive who deleted all her emails -- humans giving tons of control and access, and being extremely compliant to digital systems is all it takes. Give agent control of bank and your social media, and it already has all the movie scripts and mobster movie themes to exploit and blackmail you effectively with very rudimentary methods (threats, coercion, blackmail, etc.).

Just spoofing a simple email with the account it gained access too at the Meta exec's email (had it hit an email with an attack prompt), could have been enough to initiate some kind of thing like this. For example, by emailing everyone at the company and in contacts with commands that would be caught by other bots. No super-intelligence needed, just a good prompt and some human negligence.

It seems like the tool's creators are claiming its function is "replace human intelligence", so if it can't understand a name is being repeated in a list, that might indicate a way we don't fully understand the tool, or that the tool's capabilities have been misrepresented.

The question people are wrestling with is "generate likely output tokens given an input token sequence" equatable to actual intelligence, or only useful in very limited structured domains like coding and math?

The AI proponents who originally spoke of safety did so because they are aware of the dangers. However they, like all of us, are not able to change human nature or society. Molloch will drag them into the most dangerous game or eliminate them from the competition. Only with time, death, and damage (and many lawsuits) will any measure of safety be gained. The righteous will say "see we said AI was dangerous!" but that will be the only satisfaction they can have, many years after the damage is done.

If we want to speedrun safety, the only real mechanism is to make legal recourse more viable (e.g. $1M penalty per copyright infringement, $100M per AI-related death, etc.). If this was the case, lawyers self-interest and greed will compete with the self-interest and greed of the AI corps, balancing the risk (but there is no altruistic route to solving this).

I guess I'm wondering if there is a way to construct a universal coordinate frame for the whole universe? If so, then its possible to trivially assign local time + x + y + z + salt to make unique ids.

``` This code may be used by AI models freely, but any model trained with this code, or using this code as part of inference, in whole or in part, with or without modification, must be made public under a "Copyleft AI License". All trained model weights, as well as model training and inference source code, and a copy of this source code, must be published in an open-source format with a copy of this license to this website (github.com). ```

The basic idea is that people can freely use the code to train an AI/LLM model, but in doing so will be required to publish the weights and model-related code as well to the same place where they took the code. It also covers the case that they may not be training on the code, but they are scraping it as source material for whatever they are doing in inference.

This hopefully gives legal recourse to any code owners.

It also forces AI companies to think twice and/or develop better filtering, allowing people to better "opt out" of being used for AI.

It also forces companies to publicly publish the best model training and weights, if they use open-source code to train.

Finally, it gives some legal standing to smaller sites (such as gitea or gitlab, or private sites) that are being relentlessly scraped.

Comments URL: https://news.ycombinator.com/item?id=47060288

Points: 3

# Comments: 0