Elucalidavah

'tapping phones' gimmick strikes me as something that sounds cute but will become an annoying chore

That 'tapping phones' could also be used to facilitate key exchange verification, making that chore technically useful.

Then again, that would be better done in an open-source app and not tied to any particular domain.

Arguably, that's exactly the one action that will need to be hash-pinned, since all the consecutive actions will at least be verified against the lockfile.

any notable increase in PM2.5 particles

What's your PM2.5 baseline, and did you measure TDS in the water?

If you have a privilege to replace the kernel or bootloader, you effectively have all privileges on that system. Therefore, there's no need to complicate the access limitations when you get full access anyway.

Sounds like their "FL1 -> FL2" transition is involved in both.

Tesseract (which is the best I have so far)

Have you looked at EasyOCR?

how all the popular dynamic languages have slowly become statically typed

Count the amount of `Any` / `unknown` / `cast` / `var::type` in those codebases, and you'll notice that they aren't particularly statically typed.

The types in dynamic languages are useful for checking validity in majority of the cases, but can easily be circumvented when the types become too complicated.

It is somewhat surprising that dynamic languages didn't go the pylint way, i.e. checking the codebase by auto-determined types (determined based on actual usage).

With a physical SIM, I can pry my card out of one phone and put it into another, and expect it to work

Is anything preventing the provider from denying a SIM swap based on IMEI?

the client is not packaging up all its logic and sending a single blob that describes the fully-chained logic to the server on its initial request. Right

See "But how do we solve arrays" part:

> .map() is special. It does not send JavaScript code to the server, but it does send something like "code", restricted to a domain-specific, non-Turing-complete language. The "code" is a list of instructions that the server should carry out for each member of the array

Tangential: is "without requiring knowledge of data patterns" a frequently useful requirement? I.e. isn't knowledge of data patterns basically required for any performance optimization?

Querying a local dictionary on each clipboard seems okay; having a feature to request remote dictionaries is okay; making it easy to combine both is dubious but understandable (would be better off as a special flag); but having them combined by default? That's pretty much malicious.

Are those any better than self-hosted gitlab, or do you only mean central-hosted usage?

wrapper that supports multiple formats

Is there a way to preserve key ordering, particularly for yaml output? And to customize the color output? Or, how feasible is it to add that?

dependencies = ["httpx"]

I heavily recommend writing a known working version in there, i.e. `"httpx~=0.27.2"`, which, in the best case, would allow fixes and security patches (e.g. when httpx 0.27.3 releases), and, in the worst case, would let you change to `~=` to `==` in case httpx manages to break the backwards compatibility with a patch release.

And, of course, always use `if __name__ == "__main__":`, so that you can e.g. run an import check and doctests and stuff in it.

directory tree entry names

But... git doesn't really store directories, does it?

Realistically, either you ignore the privacy concerns and set up routing to multiple providers preferring the fastest, or you go all-in on privacy and route DNS over Tor over bridge.

Although, perhaps, having an external VPS with a dns proxy could be a good middle ground?

a garbage collected Rust

By the way, wouldn't it be possible to have a garbage-collecting container in Rust? Where all the various objects are owned by the container, and available for as long as they are reachable from a borrowed object.

Consider a "git push"-like flow: begin a transaction, read the current state, check that it matches the expected, write the new state, commit (with a new state hash). In some unfortunate situations, you'll have a commit hash that doesn't match any valid state.

And the mere fact that it's hard to reason about these things means that it's hard to avoid problems. Hence, the easiest solution is likely "it may be possible to recover Snapshot Isolation by only using the writer endpoint", for anything where write is anyhow conditional on a read.

Although I'm surprised the "only using the writer endpoint" method wasn't tested, especially in availability loss situations.

MacBook Pro M2 with 64GB of RAM

Are there non-mac options with similar capabilities?

For their fix, they disabled debug logs

For their quick fix, hopefully not for their final fix.

Hasn't been a problem yet.

You mean, refusing to integrate was the right decision after all?

when people start talking about differential equations

It's not like you are going to solve those analytically.

Implement a couple numerical solvers for things like Navier–Stokes and you'll see that differential equations is just obscenely compressed code.

need to listen to the DB for events

You could store the key->version separately, and read the said version. If the cached version is lower, it's a cache miss.

Of course, evicting something from cache (due to memory constraints) is a bit harder (or less efficient) in such setup.

There doesn't seem to be that much extra attack surface: https://security.stackexchange.com/a/271953

With an eSIM activation, the only possibility is that someone else e.g. reads the QR code from your screen and activates the eSIM on their device; but you'll notice that since eSIM activation will fail on your end, and will likely request a new one. But that does provide some window for a targeted attack.

With a physical SIM, there's a much easier attack available, in form of extracting the SIM itself from your phone. It isn't a remote attack, but it might even take you longer to notice.

Arguably, an operator's support of remote eSIM activation (whether you use it or not) is the biggest attack vector, since it allows an attacker to impersonate you and request a new eSIM.

For internet access - sure. For messages - sort-of. For calls - troublesome.

As far as I know, smartphones don't have a protocol for accessing a remote cellular network connection in the same way as if it was internal, so the only viable way is to have a hotspot device that shares the connection over wi-fi.

the object was on a rotating platform

Isn't a static-object-rotating-camera basically a requirement for photogrammetry?

Using an eSIM data on a physical sim is relatively straightforward; getting the keys from a physical SIM to use as an eSIM is relatively non-trivial, as "the card is designed to never divulge this key to the outside world".

Not to mention that a better security would involve a master key, and revocable subkeys signed with it, one for each device, instead of syncing. Not to mention n-of-m requirements.

And sure, I understand that most people need the paternalistic form, whey they are not given any guns and are also unable to export their keys from some service.

For example, with TOTP, the key is given to the user in the QR code, but common authenticator apps are unable to export the same data after it was imported. But not all; and the only bad thing about this is that the export restriction is a surprise to those who didn't expect it.

do not want individuals hosting websites

It's more about "accepting and publishing arbitrary content".

But, in practice, how hard is it to host a website anonymously? Or off-shore?

it just doesn't seem likely

It is likely conditional on the price of compute dropping the way it has been.

If you can basically simulate a human brain on a $1000 machine, you don't really need to employ any AI researchers.

Of course, there has been some fear that the current models are a year away from FOOMing, but that does seem to be just the hype talking.