It's such a shame they've closed their job board. It was the only decent developer-centric job site. Having a CV connected to SO profile was one place where the Internet Points were actually worth something.

> and doesn't try to abstract things.

The C standard is a description of an abstract machine. You get UB and unexpected miscompilations, because the optimizer is not evaluating how your code runs on the machine you're compiling for, but simulates running your code on the weirdly abstract C machine, one that can't overflow signed integers.

And C abstracts away almost everything about stack, stack frames, and all the complexities of memory and cache hierarchies. They are abstracted to be uniform linear address space.

C's memory management is its own abstraction. malloc and free are library functions. They're an abstraction not just over hardware (that doesn't have anything bytewise allocated like that), they even abstract away the way operating systems allocate memory.

You don't get direct access to the stack in C either. Stack frames are abstracted away, and you only get longjmp.

If you pay attention to Undefined Behavior and strict aliasing, you don't even get that much access to poking around memory.

Sorry, but people need to find other places to communicate and promote, because this isn't going to get any better.

Twitter was dead the moment Elon took it over. It's his toy, doing whatever he wants. Even if you pressure him, he'll reverse the throttling for a moment, act dumb as if it never happened, and then screw it again in some way. You can't win with Elon on Elon's turf.

Rust had generators first and used them to experiment with async. They're still there, stuck in nightly/unstable.

https://doc.rust-lang.org/beta/unstable-book/language-featur...

I think that's because there was a huge demand for async specifically, and Rust could ship higher level async without solving all the design details of less desired generators first.

I didn't know that, thanks for telling me.

At the lowest level Rust's async is a syntax for generators (yield).

I've (ab)used them that way, without any async runtime, just to easily write stateful iterators.

Not quite: Rust futures also have immediate cancellation and easy timeouts that can be imposed externally on any future.

In threads that perform blocking I/O you don't get that, and need to support timeouts and cancellation explicitly in every blocking call.

The pain only exists if you're trying not to use Tokio that has 90% "market share" of Rust runtimes.

I get that it is sometimes needed (if you use GTK or browser JS as your async runtime, or write your own executor).

But for majority users there is only one runtime and there's no compatibility problem. Tokio won, and network effects killed everything else. Think of it like Golang's choice of runtimes (there isn't one).

This is my impression, too! The door is open for other async runtimes, but for the majority of us, Tokio is the solution. And that's been just fine for me!

They're brand new cars. There aren't many brand new cars cheaper than that. A new Toyota Corolla costs more than $30K.

In the UK there's MG4 that is a surprisingly decent BEV for £27K (that's a price without grants/incentives), but it probably won't be available in the US, since it's a Chinese-owned brand.

"Much more" is misleading. The difference is usually 10%-20%, less than weight variance among gas cars. Tesla Model 3 weighs about the same as an ICE Ford Mustang.

Tire particles are relatively heavy and don't stay in the air, unlike smaller molecules and emission from combustion.

If weight was a real concern, non-business pickup trucks and large SUVs should be banned regardless of the engine they use.