bheadmaster

It's possible in the future we will have Rick and Morty style AI in literally everything just because it's so easy to add it.

    Sentient Switchblade: "Hi Beth! You've gotten taller! Shall we resume stabbing?"

Those who can't do, teach.

I explained in detail why value classes will not outdate this criticism. The syntax is not the point - the point is the very fact that they had to add new syntax means that they couldn't retrofit the semantics into the old syntax. Which means it's nowhere near as general and universal solution as would be required to truly make the criticism outdated - in fact it's quite limited. You can't even modify the fields, which is required for almost every scenario where value classes would be useful. For anything non-trivial, you either need to pay the immutability tax or the GC tax.

> Benchmarks prove otherwise

Well, good luck running the benchmarks on your production servers.

My criticism was not "you can't do this" - my criticism was that Java requires an overengineered GC to compensate for its fundamental language flaws that make optimization all but impossible.

Go's GC is nowhere near as complex, and yet it performs much better, because Go decided not to shoot itself in the foot.

I assume you're referring to value classes?

The very fact that Project Valhalla had to create new opt-in syntax for value classes, in order to get what Go does by default on all its types, is the admission of defeat of a herculean battle of attempting to optimize desite fundamental problems with Java's design.

Value classes won't make criticism outdated, because they don't fix any fundamental problems, they just provide an opt-in feature with significant restrictions.

Yeah, they have to be in order to make up for the braindead decision of making every variable a pointer to heap allocated memory.

Go wins not by technical ingenuity, but by simply not making fundamentally bad decisions in the first place.

What do you mean by "strict typing of its index"?

Language is more than just its syntax and features.

The most important "features" of Go are fast compilation, orthogonality of features, and easy development.

Their propositions may "look like everyone else" if you're only looking at surface syntax, but there's a reason why it took 10 years to design an acceptable generics proposal, and the result is that compiling generic-heavy code is almost as fast as compiling plain Go.

Go being strict about features it accepts is not an ideological thing, but a practical one. If Go could have all the features in the world while still being easy to use, fast to compile, and internally coherent, it would. But it can't (see: C++, C#, Python).

On ARM systems with LSE both weak and strong compile to the same CAS instruction anyway. On LL/SC, using strong means CPU will attempt to retry the same exchange on spurious failure, which increases likelihood that another thread will update the value in the meantime, requiring an outer loop retry.

On any plaform which implements strong exchange with zero overhead over weak exchange, we can safely assume they compile to the same thing, and use weak. The only reason to use `strong` is if you have a one-shot CAS operation and you don't want to write a retry loop.

> NOTE: Throughout our implementation we strictly use compare_exchange_strong, but the C++ standard suggests that for some systems like ARM it mighe be a better idea to run a loop with compare_exchange_weak for better performance. The problem with that is a compare_exchange_weak call may fail spuriously, which essentially it can randomly fail even if everything is correct, thus it makes code code a bit more complicated, so I avoided it for this implementation.

The reason using `compare_exchange_weak` is a better idea for lock-free algorithms is that, in most cases, you'll run it in a retry loop anyway. Since `compare_exchange_strong` is compiled to a retry loop, if you do a retry loop of `compare_exchange_strong` you basically have a loop in a loop. Using `compare_exchange_weak` makes things both simpler and more performant.

> allowing AI agents to act as abuse sponges for troubled people

People have been getting angry at machines for a long time. Work, you stupid printer! Asshole Windows updating at the worst time just to mess with me. Go to hell, toaster, you piece of garbage.

Getting angry at AI is the same in my book.

Yes, AI acts more human-like, yes, theoretically it could desensitie people to become bigger assholes IRL. But then again, they said similar stuff about San Andreas, where you could human figures in-game just for fun, and I don't see anyone randomly shooting people because they were bored.

VMs and containers are fairly isolated and reproducible. A separate user on your machine still depends on the programs installed locally.

For the first time in human history, military power doesn't require advantage in numbers. The rich will simply build an artificial army and use it to control everything. Kinda like Mr House from Fallout New Vegas.

Exactly. You've hit the nail on the head.

And quite frankly, your AI slop garbage radar is not just an indicator of good taste — it's the essence of humanity that keeps you above it.

I can get the same thing with an aux cable

In some corporate networks, everything is locked tight, and if you want any access (outbound or inbound), you have to send a request with business justification.

What we had was many devices behind such corporate networks. Instead of requesting exposed ports for each device, or setting up OpenVPN (never done it so I'm not sure how much the red tape would it be), I requested only outbound access to our bastion server's SSH. Since SSH is pretty standard, admins usually allow it fairly quickly.

There were also a few cases where non-HTTPS connections were also banned, so we set up an HTTPS proxy that tunneled the SSH reverse forwarding... But that's probably not needed in most cases.

How do you use -J to connect to a device that isn't publicly reachable?

There's an old blogpost I wrote at the time I came up with this method [0]. I think it contains most of the technical details.

Let me know if anything is confusing, I'll answer it here.

[0] https://paskozdilar.github.io/blog/entries/zero_code_ssh_jum...

How would you use ProxyJump with Reverse Forwarding?

If you have many different remote devices behind NATs or firewalls, a cool trick to access them all via EC2 server (or such) is to setup Remote Forwarding via UNIX socket on the server side, to devices' port 22. Preferably, UNIX socket filenames should start with a common prefix, so an SSH config can be written that will use ssh+socat in a ProxyCommand to establish the connection.

It's amazing how lightweight this method actually is. I have managed to connect hundreds of devices using a single EC2 nano instance.

Maybe superficially, but most of them are unbalanced, leading to a handful of meta builds being overpowered.

Meta-gaming is a natural progression in all human games. Chess players find "metas" like openings. It's just that video games are too simple and have very restricted meta set.

By themselves, they don't. But quantum probabilities are unique. They cannot be explained by missing information about local, pre-existing properties. Therefore, to maintain determinism, you are forced to accept extreme alternatives like non-locality (actions here instantly affecting the other side of the universe) or the existence of infinite splitting universes. If we reject those unobservable overheads, non-determinism is the most direct conclusion.

Any interpretation that asserts a deterministic universe must invent a "hidden" mechanism which causes the apparent non-determinism, and which we cannot measure nor predict.

By Occam's razor, it is more probable that the universe is simply non-deterministic.

Care to elaborate?

> Reality is non-deterministic (not actually, but in practice).

At a quantum level, it is also actually non-deterministic.

Sounds like a Death Note internal monologue.

What would constitute "consent" to being communicated information to?

With physical contact, speech can signal consent or lack thereof. How would you consent to speech itself?

> When you write Rust long enough you settle on certain architectures (message passing, event loops) that go well with the borrow checker

So basically Go?

> And if you have a local app, how do you take a dependency on whatever random model is installed?

Why not ship your own model? In the age of Electron apps, 10GB+ apps are not unheard of.