dinosaurdynasty

When synchronous is NORMAL (1), the SQLite database engine will still sync at the most critical moments, but less often than in FULL mode. There is a very small (though non-zero) chance that a power failure at just the wrong time could corrupt the database in journal_mode=DELETE on an older filesystem. WAL mode is safe from corruption with synchronous=NORMAL, and probably DELETE mode is safe too on modern filesystems. WAL mode is always consistent with synchronous=NORMAL, but WAL mode does lose durability. A transaction committed in WAL mode with synchronous=NORMAL might roll back following a power loss or system crash. Transactions are durable across application crashes regardless of the synchronous setting or journal mode. The synchronous=NORMAL setting is a good choice for most applications running in WAL mode.

But yeah most of the time it isn't an issue.

That's just the world we live in.

Let capitalism be capitalism and give people the energy and time to do things without having to justify every little thing to some pencil pusher to try and make anything happen at all.

Also there are lots of way for a company to say they are doing interesting/meaningful things or whatever and effectively not be. And no matter how great the work you may be doing, you don't want to be doing it if it doesn't pay enough.

But yeah, you shouldn't use the really complex CRDTs in that case. (And in most cases to be honest.)

The solution is to remove restrictions like "we will only give you disability/medicare if you have less than $2000 in 'non-acceptable' assets", or "you can only get food stamps if you make less than $20k/yr" or any number of horribly terrible things we do that effectively give very poor people, in an economic sense, marginal tax rates much much greater than 100%.

Punishing people for making more money is never the solution. Honestly this is one reason why UBI is so enticing... any benefit that is abruptly taken away at any point creates these horrible incentives.

OpenAI did hire somebody who is investigating watermarking the output of models like GPT-3, so it's definitely possible.

Depending on various theories of universe formation the universe could have a radius anywhere from at least 10x the observable universe to even infinite.

Example: last-write-wins register, which is a (v, t) pair, normally has a merge function of "return the pair with the greatest t (with deterministic tie breaking for same t)", and for a super peer just have v's and "the latest value to hit the server wins".

Also GC doesn't remove all resource management... ironically I find most GC-based languages to be more mentally taxing when managing manual resources (file handles, mutex locks, etc).

There's so much code in Go that is documented like "while this object takes a file handle, it does not close it itself even though there is a close function, you will need to close it" that in Rust is just a lifetime annotation.

I think, however, a lot of people would love to see other GC languages take up the safety promises that Rust provides (especially concurrency).