I don't know what forums you're on but the Rust hype is fucking nuts on HN and reddit. I like Rust quite a lot as a language but I hear about it so much that I'm almost getting sick of it, like Node.js was dominating the hype cycle years ago and Ruby before that.

Lolwut? Swift's code of conduct is lifted almost directly from Rust's, they were both based off the same original document and written by the same person. I've also never seen any "extreme"ness or SJWness in all my time on the Rust forums.

As a frequent user of several LLVM-based projects I was curious if you could contrast where it stands today with your current vision of it when you first began, and also was curious whether your departure will impact LLVM's development.

Lol, when the hell has this ever been an accepted definition? Even released, "stable" software can't meet such a pristine standard of quality, let alone beta, let alone-let alone alpha, let alone-let-alone-let alone the pre-alpha that you've been judging it by.

And then a beta release is supposed to be... what? Alpha release are _always_ crashy piles of trash, methinks you've got your standards set too high my good friend.

Servo isn't, never has been, and has never been intended to be an end-user web browser. Mozilla keeps waffling on whether they want to _make_ it one (probably because they don't want to scare off all their existing contributors on the Gecko side) but their stated priorities have always been 1. do research into parallel execution of web content whose strategies can be uplifted into existing browsers and 2. actually be embeddable, because Gecko is utter shite at the embedded-browser-engine use case.

FTFY

Rust already has a whole lot of ARM support, not all of it official. Lots of tentative embedded work being done with Rust at the moment. Here's a more updated version of the page you linked with much more detailed support information: https://github.com/alexcrichto...

Rust is dual-licensed under Apache 2/MIT, not MPL.

Here's a lovely lib for that that has a good chance of appearing in the standard lib someday: https://crates.io/crates/walkd...

Rust has pointers. Rust has pointers all over the place. What sets Rust apart is that the compiler checks code for improper pointer usage and disallows it unless you explicitly tell it to chill out using the "unsafe" keyword. It trivializes code auditing by making it so you just need to grep for the word "unsafe" to know where the source of any segfault (or any other memory error) must lie. So no, it's not a silver bullet (nothing is), but it's a hell of a lot easier to write low-level memory-safe code in Rust than it is in C.

Every language under the sun has a foreign function interface for the purpose of calling into C libraries. Does the existence of an FFI from Python obviate the need for Python? Does JNI obviate the need for Java?

Phew, glad to hear it! I'll inform the telcos that they can rewrite their infra from Erlang to PHP, since you've handily disproven the notion of safety benefits that are intrinsic to a language.

When you write C, do you enable warnings such as -Wall, -Wextra, -Weverything, -Wetc? This is an example of a tool that helps to enforce strict practices that lead to more robust products. And if you think warnings are a waste of your time, then please let me know which projects you work on so that I can remove such recklessly cowboy-coded products from my machines. Experience is no excuse for believing oneself infallible.

Ah, I see, you're rejecting this language out-of-hand because you've read a mathematical proof that programming languages must necessarily be fraught with undefined behavior like C is, and that null-based error handling like C has is the absolute and unassailable pinnacle of robust software architecture. If I may, could I ask you to link me to a text of said proof? I don't have an ACM membership, but since it's been known for "a long, long time" I would hope that it's passed into the public domain by now.

It's part of Rust's general policy of favoring explicitness, which is understandably controversial. Macros are very free-form and upon seeing a new one for the first time there's very little the programmer can assume about what they do (which, at the limit, can include running arbitrary code at compile time). In contrast, a function call is relatively easy to reason about. It's not 100% necessary by any means, though losing the syntactic distinction distinction might make many macros virtually unparseable for all I know (macros are so free-form that the current parsing tactic is "if I see the exclamation point, consume paired delimeters until they balance out, at which point I know that I'm out of the macro and can continue parsing as normal).

Actually, it will. I appeal to our shared subject line: "Have you actually tried using Rust?"