I’ve been using Rust since just before it hit 1.0. Since that time the language has gotten considerably better; non-lexical lifetimes, impl Trait, async/await, compiler performance and error improvements, and more.

In 2019 the big focus was async/await, or at least as an outsider that is how it has appeared. The end result looks like it will deliver what we’ve all been waiting for - efficient async code that works well with Rust’s borrow checker.

As 2019 is coming to a close and async/await is stabilizing, there is the obvious question - what next?

Many have suggested revisiting the 2019 roadmap. Reddit user 0b_0101_001_1010 summarizes it well in this post.

This would include taking on features like specialization, const generics, and generic associated types.

To be frank, in the last two years I have not tracked rust’s RFC’s or development nearly as much. My time goes to Grapl, to ensuring it works as best as it can, that the features I need can be implemented quickly. I do not know the specific features that I want stabilized - Rust, the language, feels quite close to where I want it to be.

GAT, async/await, const generics, etc, will all improve my development quality of life but I couldn’t really say “with these features I will finally be productive”.

Instead, my productivity tends to come down to two things:

  • High quality and stable libraries for the work I’m doing
  • Fast iteration cycles

Both of these are still lacking in rust. Maybe that’s because of a missing feature - GAT, async/await, whatever. I won’t guess which.

I remember earlier in the Rust days when custom Derive was still unstable. Constant breaking changes in libraries, tons of churn - productivity seemed impossible to me. We’re past those days, thankfully, but the same pains are still my primary pains.

Libraries that are <1.0.0 often make major breaking changes, as well as major bug fixes, leaving me with the impossible choice of having to use a broken version or break all of my code for the new version.

I want to see this change. I want whatever it is that is keeping libraries from stabilizing to be solved.

One big library for me, which can be quite painful to upgrade at times, is Rusoto. This is of no fault of the Rusoto developers - it’s a massive project - but I’d like to better understand what those developers need in order to hit a 1.0, and how the rust language (or surrounding ecosystem) can satisfy those needs. It seems to me that at least part of that is going to be solved with async/await - but I’m unsure.

Stability and quality are often transitive. A core dependency may be unstable, therefor all crates with that dependency are unstable. I’d like to see those identified and tackled.

With new features always around the corner I think library developers may be reluctant to stabilize - though that is just a guess.

In terms of iteration cycle, compile times are still quite slow, and my intellij autocompletion is as well.

I won’t prescribe solutions, I don’t know them. But these are the pain points and areas that I think would help me be productive as I continue to build a project that is primarily rust.

blog comments powered by Disqus


30 October 2019