He's showing that government can be efficient. It can help people. People can actually like their local governments. And that is completely counter to the politics of these rags and their funders.

They want to talk about how government can't work, will always be inefficient, and how it must be cut.

The people who own these papers know that the obvious solution to a lot of societal problems is "tax the rich, build out social programs" and they desperately don't want that message to get out. It makes it a lot harder to setup gig and gambling economies.

All that said, he was very online and very much not an online Nazi. To me that matters a lot more than a bad tattoo.

There'd simply be a lot worse comments from his reddit history if his beliefs aligned with his tattoo. That, to me, is why it just doesn't matter.

Like you said, for a lot of common cancers we have multiple treatments. It's usually not just one magic drug, but rather the doctors working with the most effective treatments down to the least effective treatments.

Honestly, I think people probably get false impressions because cancer usually hits old people and old people are, frankly, often not reliable narrators.

You are unlikely to see a vehicle with sodium batteries until after that happens, and it needs to be significantly less than LFPs as you Na batteries have more weight per Wh. I believe they also have a shorter lifespan (but not NMC short). Edit correction, looks like CATL is promising 15000 cycles, which is much longer than LFPs which usually come in at 7000 to 10000.

It seems far more likely to me that if the Na prices tank, you'll probably first see them deployed as grid and home battery solutions.

A fundamental problem with cops is the thin blue line is very real. The rise of cameras on cops shows pretty clearly that a decent number of cops bend over backwards to protect their own. I find it pretty easy to believe that cops won't arrest their fellow officers on a DV call.

Police unions fight HARD to stop any sort of accountability or tracking of misbehavior of cops.

It was a law written in the 90s, it should be updated and modernized.

Email is a lot harder. The older SMTP standard sends emails unencrypted so there's a possibility of a MITM reading the email. But also addresses if you get them wrong can end up in the wrong hands. For example, if someone sends an email to cogman10, I'll get it, but if they go to cogman1O I won't get it. A lot of the nuance of how secure and when it's secure gets erased by auditors to just "email is insecure".

This wasn't the case when I searched around Dec last year.

I wonder if the shift in gas prices has caused all these dealers to start stocking EVs.

I think a big portion of why Tesla is so prominent is because it's relatively easy to get a Tesla almost anywhere.

*edit* I'm out of date. It looks like the dealers around me are all stocking EVs now.

A very large portion of that ABI is already implemented due to both systems being POSIX. But further, a lot of what programs actually interact with is already ported to macOS. For example, you can build and use glibc.

Also, I get the lack of control, but that really isn't a major issue. The linux kernel pretty rarely adds new userspace additions. By and large the majority of work that goes into the kernel is around new drivers and fixing drivers. Even when there's kernel level features, it's very often not a userspace thing but rather things like new schedulers.

There's a reason MS didn't see the same approach as being too terribly crazy with WSL1, and those are very different systems. Heck, there's a reason cygwin continues to exist and work.

I'm not sure how it'd defeat the point of having their own kernel.

As for cost, possibly, but it would really be a huge boon to macOS for software devs. It's hard for me to believe that Rosetta isn't similarly costly, but it's been done because running x86 software is still very much a necessity for MacOS.

It's true that missing ABIs will cause random crashes and problems. However, a lot of apps can run with a minimal set of ABIs.

The main difference is that rust drives the VM all the way to the point of generating machine code while java generates the machine code at runtime.

Rust does a translation of the syntax to a high level bytecode, then a mid level bytecode, then to LLVM IR, and finally it lets LLVM do the translation of the IR to machine code. The way LLVM uses "VM" is exactly the same way Java is using "VM".

Javascript is similar. In fact, v8, the engine that powers node and chrome, was initially written by Java hotspot developers.

The current performance initiatives that Python and Ruby are taking are doing exactly what the JVM and Javascript does. In fact, the pypy JIT and LuaJIT are learning from and implementing what the JVM does. It's a proven mechanism to getting more performance and better optimizations.

Even GCC does the same thing under the hood.

It really is clear cut, more than you might expect.

Nope. Quite the opposite. You can precompile Java to a static runtime using the likes of Graal or even android. That actually makes these applications slower, not faster.

Part of this comes down to the Java language design. For Java, there is a lot of dynamic dispatch involved. In rust terms, it's as if almost every parameter was a `Box`. In Java, it's pretty natural to have a method like `void foo(List baz){}` which can be called by any concrete list type. In fact, compiled down, this actually looks like `void foo(List baz) {}` in the bytecode.

The JVM is able to capture runtime information and realize "Oh, `foo` is always called with an `ArrayList`. And that `ArrayList` always emits a `Bar` element." That allows it to optimize and directly call the `ArrayList` methods rather than having to always do a "Ok, determine the type, look up the method table, call the method". Which is exactly what rust has to do with a `Box` signature. To do something similar with Rust you have to do a more complex PGO compilation.

Now, don't get me wrong, rust is smart. That's why they've designed the language such that `foo: Box` just isn't as ergonomic as `foo: &Foo`. The language pushes you to use the concrete structs when possible and to avoid doing dynamic dispatch. It supports it, but it requires a lot more ritual.

There's also simply the possibility of using linux software directly in macos without doing OS dependent changes to the software.