> Where I live in SE England they seem to be trying to take productive agricultural fields out of use

I think this is an unfair characterisation. Many farmers in the UK _want_ to build solar installations on their fields as it is a fantastic way to get guaranteed income while keeping other land for agriculture. Additionally, you can graze animals with solar panels. And also the solar panel installations are usually temporary (land is leased for x amount of years), they can be removed and used as farmland after.

> how much space all these battery and solar farms

Chris Hewett, head of Solar Energy UK says this:

"We need less than half a percent of UK land, for a fully decarbonised energy grid. That is the amount of land we use for golf courses – and less than we use for airports."

https://www.bbc.co.uk/news/articles/c4geq9v60kro

FWIW, in the UK unemployment is also very low at the moment.

I was under the impression that must of Rust's compile time comes down to LLVM

It's less LLVM itself and more the amount of work that rustc gives to LLVM. Formerly for example, rustc did not do any kind of constant propagation itself and relied fully on LLVM to propagate them and say, remove any unused branches in the final expanded code. This wasted a lot of work and propagating them earlier was able to reduce compile times significantly.

So while most of the compile time is indeed usually in LLVM, there are still a lot of things rustc can do to give LLVM an easier time.

I guess using LLVM doesn't help performance, but the real 'problem' still is the language itself. Just look at C++ and it's compilers for comparison.

Swift tooling is surprisingly bad especially when It's made by a trillion dollar company. Rust's free rust-analyzer extension provides much faster and much more feature filled IDE features than XCode.

You can do this in Rust today, with the standard library's reference counter

Also, one of the easiest ways to leak memory in Rust. My understanding is that substructural typing systems are just not quite powerful enough to represent the semantics of double-linked lists, but I don't understand the math myself.

Obviously it won't leak memory if you do it correctly, but Rust will happily let you leak memory in an Rc<T>.

If you really do want to leak memory, Rc<T> is overcomplicated - just call `Box::leak` and throw away the output.

Rc<T> is the preferred way to introduce unintentional memory leaks.

Rust has a lint against this kind of attack + you can explicitly disable non-ASCII identifiers if you really want to

Ideally that lint would be on by default though. Most code doesn't use non-ASCII identifiers. It's not happened though because of uhm. political reasons.

Most code made by English speakers contains English word and Latin characters, so other languages and alphabets must be abandoned, and their native speakers must imprisoned until they understand their mistakes.

OK, OK, we can start with a warning in the compiler that use of any language except English is unsafe.

Abugidas and logographies banished

The lint is on by default in the latest version of the compiler

Housing in your area might get vastly more expensive, but housing somewhere else might not see the same price increase. The CPI is for the entire country

Because people like meat? I like meat. I don't like what happens to the animal though. I don't think it gets that much more complicated than that

Last I checked, studies on the issue of social media and mental health are pretty mixed and inconclusive. But it is a popular belief regardless

It's easy to click the button for the response you think people want to hear. Polls mean nothing except for the people being paid to run them.

I was thinking of following the book but with Bevy. How do you replace bracket-lib?

how you replace bracket-lib is the core of the exercise. There's more than one way to do it.

Translating the implementation to bevy on the fly as you read the book would probably be much more difficult than what I described.