Graydon Hoare, the original creator of Rust, shares talks and writing on compilers, language design, and early Rust and Servo.
HN links it for Rust's early history and for his compiler talks, which commenters include in lists of compiler learning resources.
> successful industrial open-source (?) projects loved by academics (Rust)
Is Rust loved by academics? And much more importantly in my mind, was it even recognized by academics before it became an industrial success?
The very first published Rust paper that I'm aware of appeared in the "ACM SIGAda Ada Letters" (https://dl.acm.org/doi/10.1145/2692956.2663188). Today that paper is the most cited paper to ever appear in that journal (which has a 4 decade history) and it's not even close. It also has more citations that all but three papers that appeared at PLDI that same year, for comparison. That certainly doesn't suggest to me that it was recognized at the time. This was also published only 6 months before Rust shipped 1.0. It wasn't that early.
My (third-hand and now-decade-old, so take it for the very little it's worth) recollection is that academic forums weren't interested in Rust because nothing in it is particularly novel in a PL theory sense (a point Graydon himself made from the very beginning, see slides 6 and 7 at http://venge.net/graydon/talks/intro-talk-2.pdf). But it did package those ideas into something that was practically usable for industry and at this point the results speak for themselves.
IMO this is a good example of why a lot of "practitioners" in industry wouldn't bother trying to publish anything in a forum dominated by academics.
Graydon Hoare's "One-Day Compilers" (http://www.venge.net/graydon/talks/mkc/html/mgp00001.html) presentation is worth a look. It uses OCaml to build a compiler for basic makefiles (using C as an intermediate language).
Kragen Sitaker has a great collection of links for amateur compiler writers on his Ur-Scheme (http://www.canonical.org/~kragen/sw/urscheme/) page.
This paper (http://scheme2006.cs.uchicago.edu/11-ghuloum.pdf) by Abdulaziz Ghuloum is also very interesting - he shows step-by-step how to write a simple native-code Scheme-like compiler by writing small C functions, compiling them with gcc, and then saving the assembly output. ("Since we don’t know yet how to do that,
we ask for some help from another compiler that does know: gcc.") Heavy theory about optimizing? Nope. Demystifying and inspiring? Heck yeah.
Graydon Hoare wrote a really nice intro to the state of compiler technology in 2019: http://venge.net/graydon/talks/CompilerTalk-2019.pdf
He shouts out to Nanopass, a way of writing highly compositional compilers developed in the Scheme world and much ported elsewhere. This kind of approach much reduces the pain of designing and maintaining compilers and can lead to very efficient compilers: it is the technology used in Chez Scheme. It's not got much take-up outside of the Scheme-aware world, despite the existence of many ports of the essential idea to other languages; I note that interesting Nanopass links keep getting submitted to HN without getting commented on: https://hn.algolia.com/?q=nanopass
IIRC, Rust's idea of controlled mutability originally came directly from the Erlang idea of immutable messages between tasks. Certainly, in the classic "Project Servo" presentation [0], we can see that "no shared mutable state" refers specifically to sharing between different tasks. I think it was pretty early on in the project that the idea evolved into the fine-grained aliasing rules. Meanwhile, the lightweight tasks stuck around until soon before 1.0 [1], when they were abandoned in the standard library, to be later reintroduced by the async runtimes.
[0] http://venge.net/graydon/talks/intro-talk-2.pdf
[1] https://rust-lang.github.io/rfcs/0230-remove-runtime.html
Graydon Hoare, a former C++ programmer on Mozilla Firefox and the original creator of Rust, acknowledges that for many people, Rust has become a viable alternative to C++ :
https://graydon2.dreamwidth.org/307291.html
And on slide #4, he mentions that "C++ is well past expiration date" :
https://venge.net/graydon/talks/intro-talk-2.pdf
It's possible that Graydon's earliest private versions of Rust the 4 years prior to that pdf were an OCaml-inspired language but it's clear that once the team of C++ programmers at Mozilla started adding their influences, they wanted it to be a cleaner version of C++. That's also how the rest of the industry views it.
Agreed for sure that working with C and C++ is the only way forward for systems languages. Rust's expression of this is the zero-cost C FFI, using native platform tooling, and stuff like that. Rust was never about re-writing the world, after all, its reason for existing was to eventually improve Firefox. The very first presentation about Rust (http://venge.net/graydon/talks/intro-talk-2.pdf) says "We are not “rewriting the browser”. That's impossible. Put down the gun."
Zig's cross compilation stuff and general compiler features, that this post talks about, is excellent, awesome, and makes me quite jealous frankly.