Nick Cameron

And the follow-up clarification post: Clarification/correction of Rust in 2023: https://www.ncameron.org/blog/untitled-2/

He wrote some decent articles before, and he might write some good ones in the future, but this right here, this ain't it. Unlike other "x in 2022" articles (for example https://www.ncameron.org/blog/rust-in-2022-2/), this one doesn't actually give any insight into the future of the language. Not only that, but there is no original content in it. He's simply repeating what he's been writing about for the past year. Maybe he should've called it PHP in 2021? Oh wait, he already did that (https://stitcher.io/blog/php-in-2021) and it's eerily similar to this article. If there is nothing new to write about, why write? I'm glad you bring up the PHP Annotated Monthly blog, it's a great resource and definitely one of the blogs to follow to keep up to date with PHP.

Yes, I've been following this issue closely. Nick Cameron is working on a revamped macro system that will replace the current compiler plugin system for the purposes of syntax extensions. It's probably still gonna be a while, unfortunately, since it'll take some time to get that kind of stuff vetted and baked into the language. Here are some recent posts by Nick on his experiments and progress (in order of publication): * http://www.ncameron.org/blog/macro-plans-syntax/ * http://www.ncameron.org/blog/procedural-macros-framework/ * http://www.ncameron.org/blog/libmacro/ Pretty much all of his recent blog posts are on the topic, so it's worth browsing through all of them if you're interested.

I'd expect something along the lines of: > Several recent studies have introduced lightweight versions of Java: reduced languages in which complex features like threads and reflection are dropped to enable rigorous arguments about key properties such as type safety. We carry this process a step further, omitting almost all features of the full language (including interfaces and even assignment) to obtain a small calculus, Featherweight Java, for which rigorous proofs are not only possible but easy. > Featherweight Java bears a similar relation to Java as the lambda-calculus does to languages such as ML and Haskell. It offers a similar computational "feel," providing classes, methods, fields, inheritance, and dynamic typecasts with a semantics closely following Java's. A proof of type safety for Featherweight Java thus illustrates many of the interesting features of a safety proof for the full language, while remaining pleasingly compact. The minimal syntax, typing rules, and operational semantics of Featherweight Java make it a handy tool for studying the consequences of extensions and variations. You can see a few of his pubs on his website: http://www.ncameron.org/papers/index.html

Rust is very advanced, with things like higher-ranked trait bounds (https://doc.rust-lang.org/nomicon/hrtb.html) and generic associated types (https://www.ncameron.org/rfcs/1598) that are difficult because they are essential complexity not accidental complexity.

Rust certainly wants to standardize the executors interface. People are working on it. See https://www.ncameron.org/blog/portable-and-interoperable-async-rust/

Agreed. I was very happy when it was announced in 2019 that Cargo got offline support: https://www.ncameron.org/blog/cargo-offline/ You can even prefetch popular libraries: https://crates.io/crates/cargo-prefetch

Faster compiler is nice, but you know what's faster? Not having to compile anything. I'm also looking forward to crates.io serving precompiled crates (https://www.ncameron.org/blog/cargo-in-2019/)

The criticism is not directed at the LSP. RLS just implements the specification, but as you said LSP doesn't create these constraints. One outcome of all this might be that RLS internally gets replaced by something like rust-analyzer, which is something that the maintainer of RLS has mused in a recent blog post as one of many possible options for the future of RLS: https://www.ncameron.org/blog/more-on-rls-version-numbering/

That's true. More importantly, Rust and Kotlin work on improving things that matter to users, not on features that read nicely in a paper, but are largely irrelevant in the grand scheme of things. Just compare Rust's announcement on tooling (https://www.ncameron.org/blog/dev-tools-in-2018/) with the state in Scala, where pretty much every promised improvement has been "around the corner" for the last 5 years. :-/ Not sure much how much can or will change here, given the departures of experienced tooling contributors in 2017.

Those three things already work in the RLS. And more: https://www.ncameron.org/blog/what-the-rls-can-do/

Expanded read list on the same topic: http://www.ncameron.org/blog/sets-of-scopes-macro-hygiene/ https://github.com/acarrico/evaluator

I think you're describing "gradual typing", which had lots of promise and attention, but arguably achieves the worst of both worlds: https://www.ncameron.org/blog/a-response-to-a-decade-of-developing-a-p… What it comes down to is a reconciliation between these two views: https://ncatlab.org/nlab/show/intrinsic+and+extrinsic+views+of+typing I think the "reliability" you mentioned is "type safety". And I think the dynamicism I sometimes miss in a language with static types is, in a bizarre way, the lack of runtime type errors. If you load a configuration file, necessarily at runtime, but the configuration file has the wrong format, an error should occur. What kind of error? In essence, a type error... Reusing the type checking machinery at runtime is a benefit to some. At the same time, the possibility of type errors (type unsafety) is a threat to the reliability of programs. I have trouble wrapping my head around it, but I ultimately want the bikeshed with both windows.

Yes: https://www.ncameron.org/blog/raft-paper/