fiddlerwoaroof

Well, the funny thing is Copernicus posits just about as many epicycles in his theory as previous geocentric theories. Only Kepler’s discovery of the equal area law and elliptical orbits successfully banishes epicycles.

Another way to do this that covers more sources of non-determinism would be to run your python code under Meta’s Hermit: https://developers.facebook.com/blog/post/2022/11/22/hermit-...

This seems like delimited continuations to me

> Also, I trust you'd be happy to have your code MINIXed, to have your code end up in closed source bootloaders locking down your new ARM laptop, and so on.

Yes, this is implied by my view that IP is a fiction

Or, because there’s so many languages around now, they just use something else. I really don’t like working with Rust myself and so I use other languages.

> The time required to charge an EV is just not acceptable for long-distance driving. It's just not. I can fill my 30 gallon V8 truck with gas in 5 minutes

I drove my Tesla Model 3 from Los Angeles to Houston and I think it may have taken an extra hour or two vs. my normal time for that route. Long distance driving already has a lot of down time when you’re stopping for lunch, dinner and other things and so spending half an hour to an hour charging at a supercharger just isn’t a big deal (if you’re doing full charges)

However, if time is important, driving until the battery hits 20% and doing five or ten minute charges is more efficient: the first 50% of the battery charges significantly faster than the second 50%, so it saves time to do more short stops vs. one long stop

I don’t maintain any particularly important software, but I would be extremely happy to know that code I wrote is used in major products everyone uses; so, I prefer to use licenses that minimize the burdens on users.

Also, I don’t think intellectual property is real and so I don’t think I can make demands on the users of my code: it seems to me that there’s an implicit contradiction in the GPL between the FSF’s anti-IP stances and their attempt to control how their software is used using IP constructs.

Me too, I really dislike meetings that could have been handled by asking me three or four questions in slack or in the PR and then waiting fifteen minutes or so for me to answer.

I’m specifically talking about selectors and things like class names, etc. I can see that you can strip the parts of objective-c that are just C.

You can’t really strip objective-c symbols, can you? I think that would break method dispatch

Or just have the environment variable used after the flags are processed

One cool thing is old non-Linux machines like the Symbolics Lisp machine and their library descendants (CLX for Common Lisp) still basically work with modern X Servers.

In my experience, the biggest issue with microservices is that they convert nice errors with a stack trace to network errors. Unless you also invest heavily in observability (usually using expensive tools), running and debugging monoliths generally seems easier

The GP of my post was:

> After losing my phone and not having a way to recover a lot of data, I've come to the realization that I don't want end to end encryption.

Effective backups and key management are 100% related to this thread

They are related: even if Signal had a backup, you’d have to have some way to recover the key when you lose your device. For example, Matrix does offer backups but you need a key to decrypt the backup if you lose access to all your verified devices.

Without some easy to use out-of-band key backup solution, an E2EE server backup is no backup at all.

A server backup is useless if you can’t decrypt it and it’s very easy to accidentally lose the keys for end-to-end decryption. I too have lost my Signal history by migrating to a new phone incorrectly.

> Cookie consent only apply to non-necessary cookies.

There’s a different issue here: lawyers and companies are often concerned that what they deem necessary will be deemed unnecessary when challenged. So, they require cookie consent preemptively to avoid liability in case they get it wrong.

There just isn’t much of the internet left outside of social media as far as I can tell

Firebird database can run both as an embedded database and as a server. I’d like to see something like Postgres adopt this model.

Maybe not, but you can install 1Password later, go to the account with the iCloud passkey and use it once, then use 1Password to generate a new passkey for that account. This flow is also generally better than trying to port keys between accounts, which adds a lot of security concerns.

LastPass definitely pops up as a usable passkey provider on iOS

This isn’t true as far as I can tell: when you create a passkey on iOS, the first screen prompts for which app to use to create the passkey and LastPass, at least, implements the necessary APIs

Do you only use first party applications otherwise? Any macOS application can poll NSPasteboard and extract your clipboard history and so I don’t see the particular concern with this class of applications.

Because people agreed that the failing test represented technical debt that needed to be cleaned up later.

A couple times I've put a "if (now() > xxxxxx) fail()` in tests for this reason.

As a general rule, the people who make this decision don’t agree; which is why we’re surrounded by slow websites.

I think libgccjit uses this technique or can use it: it reminds me of things I read about the elisp JIT in newer versions of emacs

> There is absolutely ZERO reason why a modern operating system or some rudimentary site with 10K users should not be blazing fast.

This just isn’t true: optimizing for speed is always a trade-off and, when an application is fast enough, it can be wasteful to focus on speed rather than other factors

I’ve always found that duplicating and editing over-DRY code is easier than fixing code that’s under-DRY. I strongly prefer working with people that care about DRY code and accidentally go too far than the reverse. Additionally, the worst problems I’ve had in inherited code have been due to duplication and insufficient abstractions leading to logical inconsistency.

A lot of graphql implementation end up moving the n+1 problem to the query resolver.