Ask HN: What are some good Rust code samples? Inspired by the python thread: https://news.ycombinator.com/item?id=29698198 What are some good code to read/channels to watch on twitch to learn basic to advanced rust? |
Ask HN: What are some good Rust code samples? Inspired by the python thread: https://news.ycombinator.com/item?id=29698198 What are some good code to read/channels to watch on twitch to learn basic to advanced rust? |
For advanced Rust “Jon Gjengset” has posted a number of long-form videos on YouTube that are very good. Search for it.
For code examples, find a crate in an area that you are interested in and clone the repo. There are so many to choose from that it would be unfair to single anything out. Variation is good, not bad. If you see lots of generics and macros then skip it for early learning purposes.
Instead of writing something from scratch I’d recommend rewriting something you are familiar with in but in Rust. For example, if you did advent of code (if that is your thing) in python then write it in Rust and find a repo of someone who solved the same problems in Rust.
The Rust book is excellent. https://doc.rust-lang.org/stable/book/
Jon has also released a book called "Rust for Rustaceans", aimed at intermediate ("experienced") developers, to provide them with both idiomatic and ergonomic rust solutions, as well as deeper understanding of the more advanced concerns of the language (macros, async, unsafe, ...).
Rust is somewhat "shortcut resistant" for new learners: you can pick it up by just starting coding after reading a few blog-post-length tutorials and backfilling understanding, the way many people do with other languages, but this typically takes much longer and incurs more frustration with Rust than, say, Python. That's because Rust takes longer to understand than most languages (I say this as someone who enjoys the language and expects it to become quite widely used, not as a criticism). Hence the book: it's long, but quite friendly. It's just not what you'd expect if you compare it to other learn-a-language-in-x-hours experiences.
The code is simple enough for beginners to follow, but also complex enough to demonstrate async Rust in the wild. And best of all, the code is heavily commented!
You can follow the official Tokio tutorial to implement mini-redis incrementally: https://tokio.rs/tokio/tutorial/setup
Rust is a very hard language to learn, not only because of the inherent difficulty, but also because of the lack of a structured way to approach the learning itself.
Reading codebases is a very good practice in programming, but I don't think it benefits below the intermediate (if we put it this way) level, as you may not even notice many of the design choices.
You're going to need a lot of time to become fluent, so it's crucial to clarify what's your target. If you just want to play with the language, anything will do; if you're serious, it's important to follow a path that it's stimulating, otherwise, you will just get bored and stop.
I've tried Rustlings as a beginner, but it wasn't very stimulating. Gjengset's videos are extremely slow - they could be cut to a third, and still keep the same content; again, not very stimulating.
For beginners, a possible path is to study the reference book (there's no escape from that), then optionally find a "strongly guided" projects-based book, then find some projects to work on (which may include "weakly guided" project-based books).
A project-based book I suggest is "Rust Programming By Example" (Packt). The code quality is not very good, but it has several different projects to play with.
Another book that may be interesting is (I haven't read it yet) is "Hands-on Rust- Effective Learning Through 2D Game development" (Pragmatic Bookshelf).
After you're past the strongly guided projects phase, you may start to work on weakly guided ones. Two very good books (by the same author) are "Mazes for Programmers" (Pragmatic Bookshelf) and "The Ray Tracer Challenge" (Pragmatic Bookshelf).
After that, sky's the limit, as you'll be surely ready to join established projects. The "Rust weekly" newsletter publishes projects who welcome beginners.
You may want to read, at some point, "Programming Rust" (O'Reilly). It's tedious to read it after the reference book, but it has a different, slightly more in depth, view on the Rust language.
I am always bored out by most programming language books because most of them are listing for the language's API. This is accessible through the docs. Instead, I like books, where I get to learn something new by actually doing something. That's why this book.
I also like books that teach you what the language can do, how it makes your quality of life better, or maybe ups my level by a lot. Two such books that come to mind are: 1)SICP 2)Programming in Haskell by Hutton.
I hope to learn not only Rust with it, but also 2D game programming- or at least a little of it.
I started with the Rust book earlier and made some headway, but quickly lost interest because I was far away from doing something with it, and also my work is far removed from Rust.
IMO good rust code often
- has most types, functions, macro definitions, etc. correctly commented (don't bother reading code when there are pages without comments)
- has a lot of code snippets in function comments
- has some test units
- has no unjustified `unwrap` and `expect`
- has understandable error management
- has "bench", "tests" and "examples" directories (they're not always necessary but if you see them, the author knows the tools and made some efforts in building a better crate)
- has a proper readme and lib level comments (if it's a lib): people who take pride in a readable documentation often take pride in a good code
I'd also suggest to first look at code which is neither very old (people learnt since and new features were added to the language) nor so recent it didn't mature
https://www.oreilly.com/library/view/programming-rust-2nd/97...
The book gives good visual explanations for how each of the code examples and it spends a good amount of time showing the relationship between the code examples and the borrow checker, OS, etc.
As most language books it spends a lot of time going through all the types, which I've always found incredibly boring - the same thing is the case with this book.
I'd recommend reading about strings and slices before moving on to the examples, but spread out the rest of those chapters in between the more interesting ones