Rust is what C++ should have been,
had it not escaped Bell Labs prematurely
Updated: 2 July 2021
Of course, begin with resources on the Rust programming language website: https://rust-lang.org/
There is a handy cheat sheet (and A (type-based) Rust cheatsheet), and SVG poster in addition to The Rust Language Reference and The Rust Language Grammar. Both continue as works-in-progress 3 years after 1.0-stable (released May 2015) with pull-requests or filing issues welcomed: reference or grammar.md, respectively.
Reference to the Rust Standard Library, run:
rustup doc --std
Similarly, for the de facto tutorial, TRPL (2nd Ed), run:
rustup doc --book
While there’s much to appreciate and respect about it, its style may seem verbose for some.
Now, there’s an abridged 3600 word version: Summary of The Rust Book, which addresses the critique below.
The mainline edition of The Rust Book is a work-in-progress despite having a couple of dead-tree versions.
Critique:
In technical writing, conventional practice introduces new material by directly stating the most novel concepts for the audience first, followed by elaboration and examples.
By contrast, TRPL 1st and 2nd Edition use a narrative flow typical of many bloggers, where there’s a build-up of anticipation followed by a reveal of substance. The single most useful sentence– or sometimes, phrase– within each section stating the actual idiom often gets lost within their storytelling style.
Bridging such differences: they would do well by highlighting language idioms in a sidebar (or just a bold font, inline) for each subsection.
This would preserve integrity of their writing style while accommodating both a more diverse audience and readers returning to find just the one tidbit of interest.
For those who grew up with K&R C lovingly within reach, there is another book a bit closer, in that it states an idiom first and then its companion example or explanation:
Highly recommended book: Programming Rust
(No affiliation with the authors, publisher or sellers)
As of mid-2018 and reasserted for 2nd Ed in 2021:
Blandy’s & Orendorff’s Programming Rust is the closest to a K&R C book for the Rust programming language so far.
It’s concise. It begins with the key concepts. It’s organized suitably for the pragmatic software developer with a dev-ops mindset.
For working through actual code, the canonical book for that is: Rust by Example (RBE).
Discuss on Discord. (Since the official Mozilla IRC service has been sunset, there is an unofficial #rust on Freenode.)
Edition
2021
is coming and expected to land as stable in late October 2021:
OLDER: As of 2018-12-06, Rust Edition 2018 landed as the official stable release v1.31. See Rust 2018 is here… but what is it? which beautifully depicts differences between versions and Editions.
For those migrating code from Edition 2015 to Edition 2018, be sure to run:
rustup self update
rustup update stable
cd project-predating-edition-2018/
cargo fix --edition
git diff src/foo.rs
Excellent overview of Rust language idioms:
Rust Tips and Tricks, which
concisely illustrates differences between .clone() and .cloned() among
many other principles. Still highly relevant for Rust Edition 2018!
Design Patterns: Rust Design Patterns as a Book
This Week In Rust
Follow Rust programming language and community updates. Reading just this
one is likely enough for most people, as they aggregate all of the other
major resources. (Rust Times contains some
similar, some different content.)
Official blog
Consider reading from the run up to v1.0-stable, because tracking each
update or new feature makes it cognitively easier to holistically comprehend
the current version.
Announcements on The Rust Programming Language Forum
Track possible/pending features within
The Unstable Book, but note that
many items in there may never reach stable. Also, remember to annotate any code using these features with: #![feature(foo_feature)].
Likely to be covered on one of the above websites when it’s news, but complete collection of confirmed vulnerable exploits: RustSec advisory-db
Attend Rust Conf or Rust Belt Rust. Follow conf activity via Twitter #rustconf or IRC #rustconf.
These yielded solid leads and jobs for the maintainer of this list:
Others for which the maintainer of this list has no direct experience:
Certain language features are challenging even for those who may believe they’ve grasped the core concepts.
Here are some resources found to be helpful.
Beware of silent integer overflows:
Instead of operators like a + b * c, use methods like
.checked_add().
For instance, let mut x:u8=255; x+=100; produces difference behaviour when
compiled via cargo build with and without --release flag. It will panic
without the flag, and silently overflow/wrap-around with the release
flag. This is because the default case suits the fast path for low-level
hardware. There is virtually no additional overhead for these methods, when
examining the generated Assembly language code.
Alternatively, use a BigNum library
such as one built upon GNU Multiple Precision (GMP)
like gmp-mpfr-sys
or “a big integer library with good performance,” ibig-rs.
Introduction to the mindset used by Rust:
Rust Means Never Having to Close a Socket
from pre-1.0 Rust (Oct 2014) yet still relevant in mid-2018 for concepts explained.
Be sure to also read at least the introductory chapters of
The Rustonomicon, even if you have no
intention of ever using unsafe code. Explanations given there provide a
more diverse perspective on ownership, borrowing,
lifetimes,
variance
(Vlad’s answer may help explain concepts behind the jargon),
drop check, etc.
Selection of forum posts, such as from Stack Overflow and Reddit:
unsafe exists for good reason…”
plus various follow-up commentsmemcpy when you move structs?
cargo tree -d to find conflicting dependencies
cargo install cargo-treesudo apt-get install -y libssl-dev pkg-configOPENSSL_LIB_DIR=/usr/lib/x86_64-linux-gnu cargo install cargo-treeA catalogue of Rust design patterns
Even for those coming from one of the Lisp languages/dialects and agree with
Rich Hickey that patterns mean you’ve “run out of language,” this list is
still quite valuable. (And yes, Rust has robust Macros that accommodate
many of the use cases for which Common Lisp macros are actually used.)
Podcasts:
As of Rust v1.39 (November 2019),
async/await landed
in stable.
See The Async Book (and GitHub repo)
Achieve high concurrency with Rust using far more workers than total number of OS heavyweight threads or physical CPU cores.
Rust accommodates Futures without additional runtime overhead (unlike “green threads”).
select(2) system-call. For those
using FreeBSD, use kqueue(2)/kevent(2), and for Linux, use epoll(7)
for non-trivial use cases.feature flags require some editing in order to compile with Nightly as
of 2018-07-27 and further changes as of at least 2018-09-02use std::mem::PinMut with use std::pin::PinMut in *.rsWebAssembly:
wasm-bindgen actually does under the hoodFor building webapps, start with rust-webpack-template.
For building libraries, start with wasm-pack-template.
Alternatively, MiniWASM is
“a minimalist Rust WebAssembly project template” that was created for
“projects that have more strict performance requirements” than
wasm-bindgen.
Tooling, Runtimes & Edge Computing:
Also:
Rust calling other languages:
Rust embedded into other languages:
A survey of programming languages illustrates that each serves different purposes: https://stackshare.io/stackups/python-vs-ruby-vs-rust
See Emacs config for:
use-package lsp – Language Server Protocoluse-package racer – find definition under cursor and code completionuse-package rust-modeFor non-Emacs heathens out there…
Rust Language Server (aka RLS) implements the Language Server Protocol (LSP) for Visual Studio, and it’s available within Emacs plus many other code editors.
Why you want this:
When your code editor supports LSP, you’ll get live annotations as an overlay with your code indicating programming errors of syntax, mismatched types, conflicting lifetimes, violations of API contracts, etc.
Other helpful messages are also provided from an instance of the compiler running in the background.
These messages are delivered in real-time and conventionally displayed inline or close to the offending line of code while you type it.
From the official websites and repos:
Search packages, and read their documentation:
Forum, IRC Channels and more are linked from Community page.
Academic Publications:
In no particular order:
hyper seems too minimal, consider
warp by same author&[u8], &[AtomicU8], &[Cell<u8>] and
UnsafeCellstd::error::Error trait to improve usability
#[safe] attribute for explaining why unsafe { ... } is OK.”serde_dynamodb (and other dependencies) use
rustls rather than native-tls.See also:
Recently plucked from the ‘net, most are offered without context or explanation:
cargo to generate HTML code coverage reportstop-like utility to view your running tasksThis page is a perpetual work-in-progress.
It should have begun life within a code repo, but this is what we have…
Most updates here since 2018 were gleaned from This Week In Rust. Other content since 2015 came from the various lists and fora mentioned in Stay Current above.