Nell Shamrell-Harrington: Hello everyone! I hope this podcast finds you doing as well as you can be in this very uncertain time across the world. This is the This Week in Rust update on the Rustacean station. As always, I’m Nell Shamrell-Harrington, lead editor of This Week in Rust and also a Sr. Staff Research Engineer on the Rust team at Mozilla.

This episode covers issue #349 of This Week in Rust, published on July 29, 2020.

We, and by we I mean the editors of This Week in Rust, are trying something a little different in this issue. It has been fantastic to see so many great news articles, blog posts, and videos about Rust — but including all of those in one list without breaks has made the newsletter hard to read. Starting this week, we have divided those stories into subheadings including official Rust announcements, updates on widely used Rust tooling, observations and thoughts from the Rust Community, learning resources, project updates, and a miscellaneous category that covers everything else.

Let’s go through these sections and highlight a few stories from them.

First, official announcements. There were two official Rust announcements this week — both posted by Pietro Albini on behalf of the Core team and the Infrastructure team. The first is that the Rust core team is opening up its agenda. Public agenda items will now be recorded on issues within the core team repository. The hope is that this will allow people to easily follow what is on the Core Team’s plate at any given time.

Additionally, Rust’s CI is moving to GitHub actions. We expect that this switch will considerably improve the experience for compiler contributors. Rust’s CI is extensive — we have 57 machines building and testing the compiler across all the platforms we support. Moving to GitHub actions immensely improves CI/CD speed thanks to 8 core machines now running the builds, rather than the 2 core machines that previously ran them. Rust thanks GitHub for sponsoring our CI builders. We also thank Microsoft for the Azure Pipelines capacity we used previously.

Moving on to the tooling section, both IntelliJ and Rust Analyzer have released updates — see their full changelogs for all the info.

Our next section is observations and thoughts from the Rust Community. I’d like to highlight a very interesting article from Boats called “Notes on a smaller Rust”. Many people seem to feel that there must be a smaller, simpler way to construct Rust which might be a little less powerful, but easier to use. Boats explores where they would start to create a smaller Rust and what would need to be given up in the process.

By far our biggest section this week is the one dedicated to learning resources — it is wonderful to see our Rust community members not only using Rust to its full potential but also teaching others how to use Rust by writing blog posts, tutorials, and posting videos.

The first article I’ll highlight is actually an online book called “Rust Explained using Easy English”. It is written by Github user Dhghomon. In the author’s own words:

“Rust is a new language that already has good textbooks. But sometimes its textbooks are difficult because they are for native English speakers. Many companies and people now learn Rust, and they could learn faster with a book that has easy English. This textbook is for these companies and people to learn Rust with simple English.”

This book is still a work in progress, but there is about 200 pages worth of content available now.

Tokio has released a new tutorial on Tokio and async Rust. Tokio is a runtime that can be used with Async Rust Code. This tutorial guides the reader through the basics of both Tokio and Async programming in Rust. It includes information on spawning, shared state, channels, input/output, framing, streams, and more.

Speaking of Async Rust code, Ben Shattinger has published an article titled “Async/Await for AVR with Rust.” It is a guide to implementing async code on an Arduino using Rust, including compiling and running the project, creating async operations, writing an executor, and more.

If you have trouble wrapping your head around Cell, RefCell, and Interior Mutability in Rust, you are not alone. John Alhadi has published an article that details how they came to understand these Rust concepts and how you can understand them too.

Game development in Rust is becoming increasingly popular. Ian Kettlewell shows this in their post “Making a Game in 48 hours with Rust and WebAssembly”. It covers how they implemented a game in Rust for Ludum Dare. Ludum Dare is a 48 hour solo gamejam where games are made from scratch in one weekend. Read the post for an indepth look on game design and implementation in Rust.

There were so many videos related to Rust posted this week, more than I can feature in one podcast. This week’s newsletter includes several videos in English on topics including AI with Rust, Rust GameDev Patterns, Running Rust containers, and more. We also have videos in both French and Portugues featured this week.

And that’s it for the news section of this podcast — make sure to read the full newsletter for even more fantastic Rust-related content.

Moving on to RFCs, two RFC’s were approved this week.

The first introduced a more user friendly syntax for including inline assembly code within Rust code.

The second RFC approved this week proposed adding a new function attribute called instruction set to the Rust language. An instruction set is an agreement about how software will communicate with the processor. Some processors support having more than one instruction set used within a single program. This attribute allows a user to declare what instruction set should be used when compiling a function. This allows someone to use multiple instruction sets within a piece of Rust code. This attribute will initially only be usable with certain ARM architectures, but other architectures may be added later.

There is one RFC is in final comment period this week — the ‘C unwind’ ABI. We’ve covered this RFC in detail on this podcast before, including last episode, so please give that a listen and take a look at the full RFC for more information.

Three new RFCs were proposed this week.

The first of these, called “Add JSON backend to RustDoc”, describes a design for a JSON output for RustDoc. Currently, RustDoc’s output is HTML. RustDoc did have JSON output in the past, but it failed to keep up with the changing language and was taken out in 2016. RustDoc is now in a more stable position, so it is now possible to re-introduce this feature and ensure it’s stability. Read the RFC for all the details.

The second new RFC, called “Named arguments”, proposes adding named arguments to functions. Functions would be able to have both positional and named arguments. In function calls, named arguments would be able to be specified with their name to increase readability and maintainability. For lots of examples and to see the discussion around it, check out the full RFC.

The final new RFC proposed this week is titled “Establish a new error handling project group”. It proposes creating a new project group, under the libs team, to drive efforts to improve error handling in Rust. This group would aim to reduce confusion on how to structure error handling for users in the Rust community. This would be accomplished by creating learning resources and pushing an effort to upstream widely used crates in the standard library. As a secondary goal, this project group would also try to resolve some known issues with the Error trait and reporting errors in panics/terminations.

This week’s newsletter features several job postings for Rust engineers, including at Snapview GmbH, Spruce, and Kraken.

We also have several upcoming online and in person events in the Rust community. As for online events, you can go around the world and back on August 5 and 6 by attending online meetups in Johannesburg, South Africa, Dublin, Ireland, Buffalo, New York, Indianapolis, Indiana, Linz, Austria, and Berlin, Germany. There are also in person meetups taking place in Dallas, Texas and Auckland, New Zealand.

And that concludes this week’s podcast, I hope the content in this week’s newsletter teaches you and inspires you.

This Week in Rust is edited by myself, Andre Bogus, and Colton Donnelly. This week’s contributors included, using their GitHub usernames: Imor, Nnethercote, Matthewkmayer, Darksonn, Carlosgaldino, Alex-dukhno, Jamesmcm, Lights0123,ThibaudDauce, and Shinokada.

As always, if you write a great article on Rust or happen to see one — please submit it to This Week in Rust by opening a pull request on our GitHub repo. Have a wonderful week everyone and please stay safe out there!