I don't get it why is performance such a massive issue that they still need to have an artificially low limit on the number of windows.

M-series iPads are more powerful than most of Apple's Mac Pros were. They have 8GB of RAM, but until recently so did Apple's best-selling MacBook models.

It's a "unit" in the sense of calling `rustc` once, but it's not a minimal unit of work. It's not directly comparable to what C does.

Rust has incremental compilation within a crate. It also splits optimization work into many parallel codegen units. The compiler front-end is also becoming parallel within crates.

The advantage is that there can be common shared state (equivalent of parsing C headers) in RAM, used for the entire crate. Otherwise it would need to be collected, written out to disk, and reloaded/reparsed by different compiler invocations much more often.

These kinds of perfectionism complaints keep the status quo of FPTP, which is the worst of them all.

There is a circular dependency — the language strongly influences what libraries/engines can and will be written.

Bevy and Servo wouldn't exist without Rust. Unreal probably wouldn't succeed without C++.

Languages may also matter for other reasons than just their feature set. Node.js got traction specifically because it was JavaScript.

Even though Fortran had state-of-the-art numeric libraries, Python enabled numpy to have the sweet spot of usability with good enough speed.

The killer libraries need years of effort to build them. That won't happen if users don't want to use the language, or the language isn't good enough for the task.

For Swift to have killer libraries, users must first choose Swift to build them. Catch22.

Designs have trade-offs.

In this case, it was important for await and error handling with the ? operator to be readable together.

The order of operations in `await foo()?` is ambiguous, but `foo()?.await` and `foo().await?` have an obvious and clearly visible order. As a bonus, the syntax supports chaining multiple async operations without parenthesis. `fetch().await.body().await` is much nicer to write than `await (await fetch()).body()`.

Since `await` is a reserved keyword, `.await` can't be a field access. Editors with syntax highlighting can easily color it like a keyword.

The problem looking like a field has proven to be total a non-issue in practice. OTOH the syntax avoided major pitfall of visually unclear operator precedence, inconvenience of mixing of prefix and postfix operators, and ended up being clear and concise. It's been such a success, that users have since asked to have more keywords and macros usable in a postfix form.