RustFest 2019 - A retrospective

November 2019 ยท 5 minute read

It has been a couple of days since the curtains closed on RustFest - given that I am roaming around the region, I might as well leverage my time on Catalan trains to collect my thoughts on the whole event in a digestible format.

The vibe

I feel obliged to point out that this was indeed the first time I attended RustFest (I almost made it to the Rome edition, but had to pull out before buying the tickets).

Talking to some “regulars”, it feels that I witnessed the event in the middle of a transition: a somewhat niche community gathering has now grown (alongside Rust’s popularity as a programming language) to attract more than 400 attendees, with tickets sold out several weeks before the conference starting day.

Is it a positive change? Is it a negative change?

It’s like asking a celebrity if they welcomed fame: it comes with its own downsides, but countless people have worked over the past few years to take Rust where it is now - a solid option for both amateurs and professionals willing to write robust software.
It’s “just” a matter of finding a good way to handle this new phase.

RustFest did not disappoint in this regard: we saw many new domains and applications on stage (e.g. the creative programming workshop - I wanted to be there so badly) as well as new (and not so new) issues getting the attention they deserve (Pietro’s talk on the key work that the infrastructure team is doing in the background as well Katharina’s talk on the human cost of development - seriously, watch it when the video comes out).

At the same time, you could clearly feel that the venue did indeed host many of the people (Europe-wise) who make things happen in the Rust ecosystem - you rarely exceeded one or two degrees of separation from the author of the crate or feature you were having issues with.
This amazing feeling was indeed palpable during the Implementation Days.

A digression: async/await

No point in avoiding the hot topic: it’s clear that the ongoing discussions around the latest issues in the async ecosystem somewhat affected the “peaceful” mood, but all in all I am excited to see how async-std will play out over the next few months.
I think that competition in this space is helpful, especially at this stage, and there is immense room for improvement in both ergonomics and onboarding to async programming in Rust, especially when it comes to people who have just started learning the language.

I truly appreciated Florian’s distinction when it comes to crates and binaries: we should rely on the traits exposed in futures-rs and std to guarantee interoperability between crates, while applications should be free to choose their executor without suffering any downside because of their pick.
I hope this becomes indeed the preferred approach, fostering the growth of the ecosystem as a whole.

A first

Let’s get personal: as well as being my first time at RustFest, it was also my first time coaching a workshop!

I talked about my vision for Rust in the scientific computing space at RustLab, but over the following weeks (and chatting to people at RustLab itself) I clearly understood that ecosystem readiness was not the only issue keeping us from getting our prime time.

Features and libraries cannot yield their full potential unless there is a clear path to master them and put them to use.
It’s often understated, but I do believe that writing good introductory material and documentation is extremely hard yet the benefits are enormous.

I don’t think that Rust would be where it is right now without the huge amount of work that went into the The Book and the documentation of the standard library.

When I saw RustFest’s Call for Proposal I took it as an opportunity to produce something useful to onboard people to ndarray and its ecosystem as a first step into writing scientific computing software in Rust.

The proposal was accepted and “A Machine Learning introduction to ndarray” appeared on the schedule as a two days long workshop!

I am quite happy of how the workshop played out.
I was a bit anxious about turnout - I had not been told the number of people who signed up beforehand: with so many interesting sessions going on concurrently, will there be people who are interested in giving a Rust a go for Machine Learning?
First day attendance quickly dispelled my doubts: a full room (and a few people sitting on the ground!) - there is indeed interest in these topics!

I tried to shape the workshop to be as self-driven as it could possibly be.
I took inspiration from Rustlings and the repository of F# koans - the material was structured as a series of exercises that gradually introduced you to the concepts I was planning to cover, with a strong set of tests to autonomously verify that you were indeed on the right track.
This enabled each attendee to work through the material at their own pace and I was able to give personalised support to every single one of them when needed, without having a queue of people waiting for my attention.

The material is available on GitHub.

If I could change something, in hindsight, it would probably be the workshop abstract on the conference schedule: the prerequisite on Rust knowledge should have been more prominent, thus allowing attendees to make a more informed decision.
I felt that for a couple of attendees the material was simply too much out of their comfort zone to be engaging - I tried to provide as much support as I could, but the gap was probably too wide to be bridged in two afternoons.

Onward

A big thanks to all the people involved in the organisation of RustFest - it was difficult and you did an awesome job before, during and after the event.

Some of attendees of my workshop (and others!) partnered with me during the Implementation Days.
I am finishing the last round of polishing - expect a follow-up post and a few releases next week!

I expected this retro to be way shorter, but I guess it means there was a lot to unpack.

See you all in the Netherlands for the next edition of RustFest!