JoshTriplett

We are saying the same thing: I was stating what the desirable state would be.

Among the things that need to give are 1) insurance companies should make no money because there's no margin left in the system for them, and 2) we should have several times as many doctors, which means breaking the protection racket that intentionally limits the supply.

There is no useful point to "accountable" other than "make it stop happening". The ship has not sailed. We can and should stop it.

> If all training requires a license, then none but a handful of tech giants will be able to afford the costs of training.

If the tech giants can afford the costs of training, the licenses aren't expensive enough. It should be affordable to license works for reasonable use. It should not be affordable to vacuum up the entire Internet and build an AI that competes with everyone.

> 160Wh is 160Wh.

And yet you can carry a 100Wh spare battery and a 100Wh laptop and a 15Wh cell phone...

Ultimately, an 80Wh battery and a 160Wh battery both have more than enough energy for overheating to start a serious fire. The much more important consideration is the quality of the battery controller and the physical protections on and within the battery. And it's also important that many planes now carry burn bags that they can quickly put a runaway overheating battery (or phone or other device) into.

It would make more sense to have a battery certification and require batteries to have that certification in order to carry them on a plane.

> The airline rules are a bit arbitrary. They have allowances for mobility devices but don't seem to take any extra precautions for them when they have bigger batteries. There are still a lot of dangerous gaps in airline safety when it comes to lithium batteries.

They're absolutely arbitrary. From what I've seen, one of the major problems is wild variation in quality. An 80Wh battery from six-random-letters-off-Amazon is going to be more dangerous than a 160Wh battery from a reputable manufacturer.

> Whether transparency has merit or not, tracking provenance would make the office partisan.

Tracking who added what language is in no way partisan.

The standard way you distinguish "adversary with physical possession" from "owner" is "do they have the owner's passphrase".

I'd much rather see your rough drafts than whatever AI turns it into.

Likewise; I feel exhausted after trying it for a short time, because it doesn't give any space.

Agreed. I'd love to have air purification (and air circulation to reduce CO2) without noise, to the extent possible.

> If your insert requires a parent record with a single child record, you have to get the next sequential id

Why would you need the next sequential ID, rather than just a unique ID? You could have a serial column that uses per-shard preallocations like I was describing, and allocate the IDs for both records.

There's no fundamental reason for this. Much as with per-CPU memory allocation, shards could pre-reserve chunks of the next serial space, and then only coordinate when they need a new chunk.

If we had a technique that would defeat almost every lock in the world, we might be prudent to delay releasing that until people have had time to change the locks.

Same general benefit as coordinated disclosure, except it's a big game-theory problem where we're likely to eventually have sufficiently capable defectors.

They do already exist, in multiple forms. The reason why they're not the norm, and copyright law still exists, is because the publishers with the most money won't make as much money that way.

Among the various options:

- Pay in advance, before the product exists.

- Pay for early access that other people don't have. (Yes, in the absence of copyright, people could take the early-access version and share it with others. People already do this today, and that doesn't stop folks from continuing to be patrons anyway.)

- Accept that the 0.0..01% case of absurdly popular works will end up making less money than they otherwise might have. Small price to pay for having a rich and vibrant ecosystem of people sharing things and modifying things.

The most likely answer is that they didn't think about it or didn't understand or didn't care. But on the off chance they did, perhaps they thought the DNS provider would enforce the ruling worldwide.

At this point, I think it'd be reasonable to start saying "why do we trust intermediate roots, period".

The device is in the user's possession, so you'll lose eventually, it's just a matter of how long it takes.

I like that this isn't trying to be aggressively narrow like so many other fonts do. I currently use DejaVu Mono because it feels comfortably spaced.

There is a degree to which people who have pets assume that everyone should react to animals the way that they do. If someone's dog jumps on its owner, they often react positively, rather than negatively. (In my case, the reaction would instead be "I have serious allergies and do not wish to have an unpleasant allergic reaction for the rest of the day".)

Some dog owners (to be clear, some, not by any means all, but it only takes some to affect other people's general perceptions) seem to think they are objectively correct and the people who do not want that are wrong. So it is not hard for me to imagine someone who finds themselves regularly having unpleasant interactions with dogs feeling like "dog owners should stop that from happening", rather than (as is sometimes the case) acting like there's something wrong with people who think it's a problem. Conversely, it is understandable how people who are close to and friendly with an animal all day will sometimes fail to have sufficient perspective-taking to realize that not everyone feels as they do.

I've personally never had the extremely unpleasant experience of having a large dog try to jump at me. I have on rare occasions had the experience of having a small dog run at my legs, and the owner not immediately treat that as a failure on their part, which was unpleasant. Fortunately, most of those have then had the "I'm so sorry" reaction, rather than reacting with indignance, but I've definitely encountered pet owners who projected indignance that you don't think their animal is a precious sweetums who can do no wrong.

Most pet owners are extremely reasonable people, and it's unfortunate that encounters with the exceptions to that can give people a poor impression.

Flash dying is a great victory for Open Source browsers. I don't miss a thing about that world; as an authoring tool, it was hugely overused, for things it should never have been used for, like literally anything other than games.

I am thinking of it as markup. I stand by the point: I think "forgiving" is not a feature in parsing; it's a bug.

I don't think "parsed strictly" makes something hard; on the contrary, I think it's helpful to make something easy. Clear feedback, easy to test.

But then, I've always preferred strongly typed over stringly typed.

With the benefit of hindsight, if the web had been that way from the beginning, I think we would have been better off. The moment you tested your content in any browser, you'd immediately see if it was broken.

But it wasn't something that could get introduced later, after all the broken content that already existed.

> I chopped the 118 KB off the front and threw it into IDA

How long until someone uses AI to find an exploit in IDA and starts putting that in their malware, so that if you try to disassemble it you get pwned?

That's exactly what I was thinking when I saw https://www.assbench.com/ posted a while back: "oh no, this is going to be somebody's job".

It is important to try, for a few reasons. Among other things, increasing amounts of Rust written in the Linux kernel itself, and other environments where you need to take more care with memory allocation.

Rust as a language is capable of that. If you don't use the standard library then you can provide that functionality yourself. The standard library is trying to support it, without creating interfaces that are a massive pain to use.

For instance, it's easy for us to support `Vec::try_reserve`, and we do, but that's not trivial for users to use everywhere; it's error-prone, and it's easy to make a mistake and call a method that goes past your reservation. It's painful for us and for users to make `Vec::push` support this (and having a `try_` variant for every function), so we've been working on a better solution. One current possibility is to have a dedicated type for a Vec that has OOM handling, where `push` can return an error, so you know if you use that type you can never accidentally fail to handle OOM.

Yup. UFO conspiracies, aliens on the moon, PSI...

I've always used https://screenmessage.com/ for this.

bigwords has the advantage of accepting inline parameters though.