sgsjchs

He's automating you out of a job just as well though, whether you keep yourself in the loop or not.

Types may be mostly marshallabble, have a subset of values that are unmarshallable. E.g. non-finite floats.

> AI is still just as bad at sales, marketing, writing and anything involving human subjective appeal as it was a year ago.

All of these have objective metrics (units sold, clicks, likes, etc) and are thus verifiable in principle.

This arch uses engrams aka per layer embeddings. Not all of those GBs need to go in vram.

weak aura

> The reality is that humans are far cheaper than robots in most real world situations.

Do you expect this to be true indefinitely? Robot production scaling has barely started.

It needs to be facing open space instead of other parts of itself, otherwise the radiation is just reabsorbed.

This test implies that phantasiacs immediately lock down the full visual fidelity (the orientation of the die), before you specified it. Why would they? I find myself capable of imagining the die in superposition, same as I don't imagine any particular color it has or any surface it may rest on.

What happens when a user without the cookie GETs a slow page? Does he get redirected to fast one to and back?

Maybe I misunderstand what you mean by "load the cookie". What is it if not Set-Cookie header with redirect status? That doesn't seem particularly special to me.

It's not reusable from a different IP.

How so?

It discards the cookie after one request and appears as a new user.

The people "consented" to this when they clicked OK on the user agreement.

Ironically, defense by obscurity may be the way to go here.

Fork Anubis. Slightly modify the hash function it computes. Deploy. Do not try to make your fork widely adopted. Do not even publish it.

You've just defeated ASICs and any craweler that's special-cased Anubis (currently all of them). If enough people do this, the only recourse they will have is either genuinely executing served js code like a real user or building some unholy pipeline that uses ai agents to compile it to a GPU kernel for every host.

it'll load the cookie, make one request, move to a different ip, load the cookie, make one request, move to a different ip, ...

> dictionary based compression

That corresponds to PCFG models.

The first LZ-step pretty much directly maps to BPE tokenization in LLMs.

Make multiple nodes do the same job, compare results.

You have it backwards.

This formal game-theoretic notion of fairness acknowledges that power disparity exists and that having less power than your counterparty allows them to inflict greater disutility on you without you being able to inflict disutility on them in turn to discourage this.

On the other hand, fairness "in the usual sense", pretends power disparity doesn't exist and that, say, an armed robber is not allowed to take your stuff when you have nothing to defend yourself with. Which in reality only works as long there is a powerful third party (the state) that will inflict disutility on the robber for it.

Does it really matter that English is not as precise if the agent can make a consistent and plausible guess what my intention is? And when it occasionally guesses incorrectly, I can always clarify.

It's the other way around.

The trick is to provide dense rewards, i.e. not only once full goal is reached, but a little bit for every random flailing of the agent in the approximately correct direction.

I, too, enjoy the craftsmanship, but at the end of the day what matters is that the software works as required, how you arrive at that point doesn't matter.

> I still don't understand this decision.

Variable declaration `T v;` means "declare `v` such that expression `v` has type `T`". Variable declaration `T *p` means declare `p` such that the expression `*p` has type `T`". etc.

But in C that's just syntax sugar for pointer math.

You very rarely would actually want scalar types which don't map directly to hardware supported ones anyway.

Why would you want to store arbitrary individual passwords instead of deriving them with on demand from the service name/domain and a common secret?

Indeed, the "valid but unspecified state" refers only to some types defined in the he standard library. It essentially means that you can only call methods which have no preconditions and don't depend on what that state is, e.g. assignment or destruction, or something like string::clear or vstring::assign if you want defined outcomes. In general each type is free to guarantee whatever the author wants about the moved from state, e.g. moved-from std::unique_ptr is always null.

> No, the class can use a sentinel value internally only to mark moved-from objects. That's exactly where we actually started the conversation.

The issue is that the "moved-from" state is exposed to the user when the moves are not destructive. The author of the class has to consider behavior for every method in sentinel state, even when it's just to assert that the state isn't sentinel or "lol it's UB". And the user has to be careful not to accidentally misuse an object in sentinel state. Just like how every time you touch a nullable pointer you have to consider if it can be null and what to do in that case. As long as the sentinel state is exposed at all (via non-destructive move), there is little gain in not providing full support for it. However, with destructive moves the sentinel value either doesn't exist at all or only exists completely internally as an optimization, and all this mental overhead disappears.