dminik

Yeah. I don't want to be conspiratorial, but there is some heavy censorship happening in certain (or maybe most) subreddits.

A good example is worldnews. For a long time I thought it was a pretty good source of, well, news. But at some point I started noticing that certain topics (cough Negativity about Israel cough) which got a decent amount of discussion were deleted as duplicates of posts that came in later and had 0 comments and could not be seen on hot/top/whatever.

Back to your topic, I think this is in large part due to the death of multiple forums and personal websites and the aggregation of everyone to like 4 platforms.

In the past, if you were banned or didn't like one forum, you could find another. Or maybe just post your thoughts on your own website/blog. But now nobody will see it unless it's on reddit, discord or YouTube.

I don't think we can get that back, but maybe a bluesky(-ish) forum/reddit alternative where you can chose who you interact/see posts and comments from would work well. It would take another collosal fuckup to get people to move and even then... Lemmy was alive during the API/third party apps thing and nobody really moved.

My recipe book has 300 AIs and all are delicious. Google Maps running A* or whatever is obviously not AI. Come on.

I would say that it is. During use, I have noticed that these systems tend to attempt to escape sandboxes, bypass permissions and other similar things. I have started to watch what they do and step in if something is going wrong.

The teams at OpenAI know this as well and yet there was no supervision. Thousands of instances of these advanced systems are allowed to run wild with no oversight.

I have my doubts that the HuggingFace hack would happen if a person was reading the thoughts and executed commands as they happened in real time.

That's the negligence.

I'm not a particularly big believer in infinite growth, so I'm not really concerned. But, I have noticed that many people both complain that nothing is being built, but also NIMBY. Could be the goomba fallacy...

Each nixos rebuild creates a snapshot. While I also eventually moved off of nixos, I've yet to get a system that was as stable as it.

Is it not the intent if it keeps happening again and again and the companies responsible aren't doing anything to stop it?

No, you aren't propping up the US economy. Try to keep up.

I don't want to do the "check his hard drives" thing, but is that you? Do you only not do things because you don't want to be seen doing "unkind things"?

It feels like you're strawmaning alignment. People with hacking knowledge don't all hack everything at the slightest inconvenience. Whitehats exist and use that same knowledge to defend.

You're right though that ethics don't matter into it. But as long as we can't train an LLM to stop picking a sledgehammer to remove a tooth, then alignment is not easy and trivial.

I see that they're not on HN either.

If they don't get punished for it, why not?

> Looks to me like I can run Claude Code without being able to afford my own datacenter.

Well, unless of course you want to train your own LLM, or do some biochemistry (and increasingly just regular health stuff) or cybersecurity. These capabilities are not made available for plebs like you or I.

I wish languages made it easier (or possible) to track index ownership at compile time.

The global town square is locked up in a gated community.

> This is one of the core issues with LLMs and vibe coding, yes. The only complete specification for a program is the machine code.

I agree, yes. But it's a bit like saying the only way to not die in a car crash is to not drive. If we're in a situation where using LLMs is unavoidable, I would rather make them safer.

> Well there’s your first problem. A line in the prompt is not a safeguard. Even if you could trust the model - and you cannot - there is always the issue of prompt injection. A proper safeguard means actual sandboxing.

You're right. I did not completely sandbox it and air gapped it. But I also wented it to do some actual work.

If I completely sandbox it, but still leave it the ability to compile stuff, it's just going to build it's own (bad) version of the tool. That's obviously not what I want either.

The obvious thing to me would be for the LLM to notice it's limitations, reason through why they might exist and explain to the user that it cannot do it's job without such and such.

But that brings us to my original comment that these things are over-optimized on completing the task by any means necessary.

Ok, but "followed the prompt" is very vague. Human languages are quite ambiguous so you're never going to properly specify everything.

For instance, I was playing around with Claude a few days ago and it decided that it was missing a tool and it was going to get it one way or another.

First, it tried apt. No sudo, so no install that way. Tried installing via mise, but it didn't have the permissions. Then moved on to grabbing the source from github and building it.

Should I have included a "DO NOT UNDER ANY CIRCUMSTANCES INSTALL ANY TOOLS"? I mean, I had to after that. But how many other things am I missing? And at what point do the safeguards become so long they get consumed by compaction, or just ignored by the model?

I have trouble imagining that Google could seriously argue that printing tens of millions of lines of code would be customary.

I doubt Google is distributing the Android code to third party OEMs that way.

I mean, this is a very weird take to me. Like, we're fine with AI going like "hmm, maybe the user actually wanted me to hack the pentagon" and going through with it?

It feels like the models have been very optimized at getting shit done. But not so much at figuring out what the limits should be.

That is still dangerous and it shows that the models ARE misaligned with what their users are wanting/asking them to do.

True, but Bun actually has a similar problem. It's creating bindings to a JS runtime. If the JS glue code then no longer uses it, the code is still marked as alive because it's registered with the runtime.

I really don't understand the thought process here.

Judging by public statements, Google is one of the 3 big western AI companies. Surely they should be rolling in cash and working hard towards AGI.

And yet, for whatever reason, they can't help themselves from further restricting user freedoms on Android. Why?

I don't want to be conspiratorial, but surely it's not money, right? It has to be control. Someone high up at Google just seems to resent people having control over their own devices.

I mean, how do you check that your frontend code (possibly not even managed by your team) is calling and needs all of your backend endpoints? I'm sure it can be done, and it probably should, but saying it should always be 0% is not very pragmatic.

You know, we used to develop on computers with less than a Gig of RAM. A phone with 6/8/12 GB should be plenty enough to to do some development on. Or even less if you don't need to compile.

Seriously, you can run the windows version of GTA V on a phone. It runs pretty ok as well.

Syntax aside, programmers and mathematicians have a very different view on how things should be done.

Programmers look at data and see opportunities for running a pipeline of transformations (map/filter/...). And they tend to write their SQL like this as well. Or use something like Linq or one of the various pipe syntax SQL extensions.

I would say that this is a major reason why there is this sentiment of "SQL is yucky" by developers. The mental models just don't match.

Maybe. Was it wrong to call Madoff a fraudster in the early 2000s?

Now, I don't think this is necessarily a Madoff situation, or even a dotcom one. Ed Zitron is certainly not Markopolos. Especially evidence wise.

But, getting a date wrong doesn't necessarily mean that he's wrong in general.

Maybe all of those authors exploring dystopian cyberpunk settings were onto something.

Tbf, he only has to get it right once.

I guess my point was that it doesn't matter whether your framework/library is immutable/mutable/retained/functional/MVC/MVVM or whatever. You're hitting platform limitations one way or another.

But the rest of your app still gets the simplicity of a declarative programming model.

Fair, the standard library is not quite so awful. There are still some pretty long names in it though.

https://docs.oracle.com/en/java/javase/23/docs/api/java.base...

Or this 6 word beast: https://docs.oracle.com/en/java/javase/21/docs/api/jdk.dynal...

This is probably the most enterprisey sounding, but not the longest class I could find: https://docs.oracle.com/javase/8/docs/api/javax/naming/spi/I...

No offense, but this doesn't seem like a realistic way to look at things.

Autodesk (since you mentioned CAD) itself dates back to 1980s. And even then, they had at least 15 people working on AutoCAD. That's a small team size. Today, they have over 14000 employees. Some random website tells me they had ~5000 of them 20 years ago. You can make anything work when you throw an army of people at it. It's not exactly a good point towards small teams being able to build complex imperative/OOP apps.

That's not to say that Apple is not dropping the ball here. I don't really have any Apple devices to check for myself, but I know that Microsoft, for instance, has been doing much more than just dropping the ball when it comes to UI. But, I'm not sure that has anything to do with imperative vs declarative.

To make complex layouts (flex, ...) and have them run performantly you need some form of a retained backing state anyways.

The main difference between various retained, OOP, functional, immediate, declarative, ..., approaches is how they treat this state.

For imperative/retained/OOP libraries, you operate on this state itself. Your nodes/widgets know their own state, how to render themselves, their place in the hierarchy and so on.

For immediate/functional(?) libraries, this state is a cache. It's not something you work with directly.

Despite not really liking React itself, I think it has found the best model.

You take a retained core, possibly OOP, maybe ECS or whatever, and you write a declarative wrapper around it. This lets you escape the easy-mode declarative landscape when needed, but most UI can still be simple to write.