There are schemes where you don't need key pairs for each user (assuming the government has some way of authenticating users). Private State Tokens use blinded tokens for this.

It doesn't prevent tokens from being stolen or sold, but the token issuer only accepts each token once and can limit the rate that tokens are issued and control how fast they expire, giving decent control over how practical using stolen or sold tokens are.

It doesn't necessarily have to be white mold either. Anything that generates a persistent immune response can keep it going once it triggered. Like really bad allergies.

So your "evidence" is the transcript of an interview that references an indictment containing information that hasn't been publicly substantiated.

There was also testimony to the Congress by its CEO which wasn't very convincing. There is a dude running for congress in Maine who has a troubling political background due to his past associations and this guy could not call him out. I'm pretty sure if the congress hopeful were running as an IND or repub he'd be treated differently by this organization in question.

Even if they're more productive, the amount of work to be done has also increased significantly. Not only is there so much work to be done on AI integrations but all of the other products have bug trackers exploding with new privacy and security vulnerabilities that need to be addressed.

Some of the security people I work with claim that without the productivity gains from AI, there is no way they could keep up with the bugs.

Theoretically, that's true. In practice the gains were limited to the wealthy who use that money to fund increasingly deranged start-ups* until the market crashes. Then rinse and repeat. The failed start-ups effectively waste any increased productivity leaving everyone about where they were before.

*They fund these start-ups to get a good return on investment so they can get even more money. As the economy overheats the number of places to invest with a reasonable return falls so they are left with the high-risk stuff to invest in. I'm not sure what they want the money for, though, since they could already afford most of the things I would find useful...

I think funding deranged startups is a type of consumption, and it does get money back into the economy the same way funding a remodel does. Maybe the reasoning to do so is different, and maybe the deranged startups add more capital than a bathroom remodel, but then again, bathroom remodels probably tank less often than startups, and worst case you can always read a magazine in your new bathroom. hard to do that in a dead startup

How do you handle object disambiguation with YOLO? All the examples I've played with have the problem where if two "cars" get too close to each other then the tracking IDs keep switching between them, meaning we'd need an additional kinetic model for disambiguation.

Ick. The entire article starts from the fundamentally flawed premise that "you want a function that takes a blob of memory as an argument". Then they discuss bytewise access into structures..

Passing around void pointers is simply not a safe thing to do in C++. You can't do anything with a void pointer, so you're probably going to cast it as something else. Use that type instead, so that your caller knows they need to pass a valid pointer to that type. If the pointer has the wrong alignment then that will result undefined behavior. If you need to support multiple pointer types, use templates.

And, unless there are some really weird circumstances, you actually don't want to access your structures bytewise. Offsets can shift with compiler flags/versions. If you want serialization , please use a serialization library that correctly handles all of the odd cases. These can be quite efficient.

I've only actually had to munge bytes in a class once. Somebody decided that a previously POD class that was passed between processors with different memory spaces needed a virtual function, so I had to overwrite the vtable when I received it to make it valid.

In general, you're right.

The exception that I could think of is a "dump memory" function. You take a pointer to something (who cares what it is), and print out the bytes there. That I could see taking a void*.

But that's a really limited case. In general, yes, you do not want to be dealing with blobs of memory as arguments. You want to be dealing with things that are known to be the right kind of thing as arguments.

But parent is right, you have to cast it anyways before reading from it, so might as well take the right type from the beginning.

Anything can be aliased by char, unsigned char, std::byte (as well as signed char in C), and usually uint8_t == unsigned char, thus by extension any valid void pointer can be cast to u8*.

Thus void*+size is usually the right type if ones only care for the memory representation of an object (cstring functions like memcpy, etc.)

Most likely one would have both overloads:

    void Hexdump(const void *p, size_t size); // (1)
    
    template<typename T>  // (2)
    inline void Hexdump(const T &obj) {
         return Hexdump(&obj, sizeof(T));
    }

With (2) being a wrapper to (1) that compilers will almost always inline, avoiding monomorphization costs (and (2) can also accept rvalues as argument).

(1) could also take std::span<const u8>, but (void*, size) is the more common idiom, more convenient to use and to read , as it is unambiguous which overload it is.

Why not both?

Chess games are in their training set, other games are not.

Chess is representable entirely in text as well, and generally speaking the LLM concept of "picking the next best token" fits pretty well for "picking the next best move" where a move is a text token

That representation is also old, incredibly well documented, and used to describe how to reason about chess. There are of course text guides to other games in training data but they rely upon depictions of what’s happening that aren’t purely text so the game harness is always going to have to make novel decisions about represent the game as text.

But there's nothing stopping AI from developing domain expertise. If you fine tune a model based on the records of all previous work (effectively "shadowing" the existing workers) then it can easily learn this domain knowledge. The only difference is that AI companies have gone after programming domain knowledge first. Others will come later.